From a8728921852a13633ad9167e12182867bc18f15b Mon Sep 17 00:00:00 2001
From: Jeremy Howard <j@fast.ai>
Date: Thu, 5 Mar 2020 13:57:14 -0800
Subject: [PATCH] rename

---
 .gitignore                                    |    3 +
 11_midlevel_data.ipynb                        | 1267 +++++++++
 11_nlp_dive.ipynb                             | 1315 ---------
 12_better_rnn.ipynb                           | 1154 --------
 12_nlp_dive.ipynb                             | 2350 +++++++++++++++++
 14_deep_conv.ipynb                            | 1044 --------
 15_resnet.ipynb => 14_resnet.ipynb            |   68 +-
 ...rch_details.ipynb => 15_arch_details.ipynb |   50 +-
 17_accel_sgd.ipynb => 16_accel_sgd.ipynb      |  376 ++-
 19_foundations.ipynb => 17_foundations.ipynb  |   58 +-
 20_CAM.ipynb => 18_CAM.ipynb                  |   20 +-
 18_callbacks.ipynb                            |  419 ---
 21_learner.ipynb => 19_learner.ipynb          |  214 +-
 22_conclusion.ipynb => 20_conclusion.ipynb    |   14 +-
 14 files changed, 4220 insertions(+), 4132 deletions(-)
 create mode 100644 11_midlevel_data.ipynb
 delete mode 100644 11_nlp_dive.ipynb
 delete mode 100644 12_better_rnn.ipynb
 create mode 100644 12_nlp_dive.ipynb
 delete mode 100644 14_deep_conv.ipynb
 rename 15_resnet.ipynb => 14_resnet.ipynb (98%)
 rename 16_arch_details.ipynb => 15_arch_details.ipynb (89%)
 rename 17_accel_sgd.ipynb => 16_accel_sgd.ipynb (86%)
 rename 19_foundations.ipynb => 17_foundations.ipynb (96%)
 rename 20_CAM.ipynb => 18_CAM.ipynb (99%)
 delete mode 100644 18_callbacks.ipynb
 rename 21_learner.ipynb => 19_learner.ipynb (98%)
 rename 22_conclusion.ipynb => 20_conclusion.ipynb (95%)

diff --git a/.gitignore b/.gitignore
index 87620ac..794a30f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1 +1,4 @@
+__pycache__/
+.last_checked
+.gitconfig
 .ipynb_checkpoints/
diff --git a/11_midlevel_data.ipynb b/11_midlevel_data.ipynb
new file mode 100644
index 0000000..40f0f67
--- /dev/null
+++ b/11_midlevel_data.ipynb
@@ -0,0 +1,1267 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#hide\n",
+    "from utils import *\n",
+    "from IPython.display import display,HTML"
+   ]
+  },
+  {
+   "cell_type": "raw",
+   "metadata": {},
+   "source": [
+    "[[chapter_midlevel_data]]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Data munging with fastai's mid-level API"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We have seen what `Tokenizer` or a `Numericalize` do to a collection of texts, and how they're used inside the data block API, which handles those transforms for us directly using the `TextBlock`. But what if we want to only apply one of those transforms, either to see intermediate results or because we have already tokenized texts. More generally, what can we do when the data block API is not flexible enough to accommodate our particular use case? For this, we need to use fastai's *mid-level API* for processing data. The data block API is built on top of that layer, so it will allow you to do everything the data block API does, and much much more."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Going deeper into fastai's layered API"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The fastai library is built on a *layered API*. At the very top layer, there are *applications* that allow us to train a model in five lines of codes, as we saw in <<chapter_intro>>. In the case of creating `DataLoaders` for a text classifier, for instance, we used the line:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from fastai2.text.all import *\n",
+    "\n",
+    "dls = TextDataLoaders.from_folder(untar_data(URLs.IMDB), valid='test')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The factory method `TextDataLoaders.from_folder` is very convenient when your data is arranged the exact same way as the IMDb dataset, but in practice, that often won't be the case. The data block API offers more flexibility. As we saw in the last chapter, we can ge the same result with:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "path = untar_data(URLs.IMDB)\n",
+    "dls = DataBlock(\n",
+    "    blocks=(TextBlock.from_folder(path),CategoryBlock),\n",
+    "    get_y = parent_label,\n",
+    "    get_items=partial(get_text_files, folders=['train', 'test']),\n",
+    "    splitter=GrandparentSplitter(valid_name='test')\n",
+    ").dataloaders(path)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "But it's sometimes not flexible enough. For debugging purposes for instance, we might need to apply just parts of the transforms that come with this data block. Or, we might want to create `DataLoaders` for some application that isn't directly supported by fastai. In this section, we'll dig into the pieces that are used inside fastai to implement the data block API. By understanding these pieces, you'll be able to leverage the power and flexibility of this mid-tier API."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "> note: The mid-level API in general does not only contain functionality for creating `DataLoaders`. It also has the *callback* system , which allows us to customize the training loop any way we like, and the *general optimizer*. Both will be covered in <<chapter_accel_sgd>>."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Transforms"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "When we studied tokenization and numericalization in the last chapter, we started by grabbing a bunch of texts:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "files = get_text_files(path, folders = ['train', 'test'])\n",
+    "txts = L(o.open().read() for o in files[:2000])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We then showed how to tokenize them with a `Tokenizer`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(#228) ['xxbos','xxmaj','this','movie',',','which','i','just','discovered','at'...]"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "tok = Tokenizer.from_folder(path)\n",
+    "tok.setup(txts)\n",
+    "toks = txts.map(tok)\n",
+    "toks[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "tensor([   2,    8,   20,   27,   11,   88,   18,   53, 3286,   45])"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "num = Numericalize()\n",
+    "num.setup(toks)\n",
+    "nums = toks.map(num)\n",
+    "nums[0][:10]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "And how to numericalize, including automatically creating the vocab for our corpus:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "tensor([   2,    8,   20,   27,   11,   88,   18,   53, 3286,   45])"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "num = Numericalize()\n",
+    "num.setup(toks)\n",
+    "nums = toks.map(num)\n",
+    "nums[0][:10]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The classes also have a *decode* method. For instance, `Numericalize.decode` gives us back the string tokens:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(#10) ['xxbos','xxmaj','this','movie',',','which','i','just','discovered','at']"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "nums_dec = num.decode(nums[0][:10]); nums_dec"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "...and `Tokenizer.decode` turns this back into a single string (it may not, however, be exactly the same as the original string; this depends on whether the tokenizer is *reversible*, which the default word tokenizer is not at the time we're writing this book):"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'xxbos xxmaj this movie , which i just discovered at'"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "tok.decode(nums_dec)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`decode` is used by fastai's `show_batch` and `show_results`, as well as some other inference methods, to convert predictions and mini-batches into a human-understandable representation.\n",
+    "\n",
+    "For each of `tok` or `num` above, we created an object, called the setup method (which trains the tokenizer if needed for `tok` and creates the vocab for `num`), applied it to our raw texts (by calling the object as a function), and then finally decoded it back to an understandable representation. These steps are needed for most data preprocessing tasks, so fastai provides a class that encapsulates them. This is the `Transform` class. Both `Tokenize` and `Numericalize` are `Transform`s.\n",
+    "\n",
+    "In general, a `Transform` is an object that behaves like a function, has an optional *setup* that will initialize some inner state (like the vocab inside `num` for instance), and has an optional *decode* that will reverse the function (this reversal may not be perfect, as we saw above for `tok`).\n",
+    "\n",
+    "A good example of `decode` is found in the `Normalize` transform that we saw in <<chapter_sizing_and_tta>>: to be able to plot the images its `decode` method undoes the normalization (i.e. it multiplies by the std and adds back the mean). On the other hand, data augmentation transforms do not have a `decode` method, since we want to show the effects on images, to make sure the data augmentation is working as we want.\n",
+    "\n",
+    "The second special behavior of `Transform`s is that they always get applied over tuples: in general, our data is always a tuple `(input,target)` (sometimes with more than one input or more than one target). When applying a transform on an item like this, such as `Resize`, we don't want to resize the tuple, but resize the input (if applicable) and the target (if applicable). It's the same for the batch transforms that do data augmentation: when the input is an image and the target is a segmentation mask, the transform needs to be applied (the same way) to the input and the target.\n",
+    "\n",
+    "We can see this behavior if we pass a tuple of texts to `tok`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "((#374) ['xxbos','xxmaj','well',',','\"','cube','\"','(','1997',')'...],\n",
+       " (#207) ['xxbos','xxmaj','conrad','xxmaj','hall','went','out','with','a','bang'...])"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "tok((txts[0], txts[1]))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Writing your own Transform"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "If you want to write a custom transform to apply to your data, the easiest way is to write a function:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "3"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def f(x): return x+1\n",
+    "tfm = Transform(f)\n",
+    "tfm(2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`tfm` will automatically convert `f` to a `Transform` with no setup and no decode method. If you need either of those, you will need to subclass `Transform`. When writing this subclass, you need to implement the actual function in `encodes`, then (optionally), the setup behavior in `setups` and the decoding behavior in `decodes`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class NormalizeMean(Transform):\n",
+    "    def setups(self, items): self.mean = sum(items)/len(items)\n",
+    "    def encodes(self, x): return x-self.mean\n",
+    "    def decodes(self, x): return x+self.mean"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here `NormalizeMean` will initialize some state during the setup (the mean of all elements passed), then the transformation is to subtract that mean. For decoding purposes, we implement the reverse of that transformation by adding the mean. Here is an example of `NormalizeMean` in action:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(3.0, 5.0, 2.0)"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "tfm = NormalizeMean()\n",
+    "tfm.setup([1,2,3,4,5])\n",
+    "start = 2\n",
+    "y = tfm(start)\n",
+    "z = tfm.decode(y)\n",
+    "tfm.mean,y,z"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Note that the method called and the method implemented are different, for each of these methods:\n",
+    "\n",
+    "```asciidoc\n",
+    "[options=\"header\"]\n",
+    "|======\n",
+    "| Class | To call | To implement\n",
+    "| `nn.Module` (PyTorch) | `()` (i.e. call as function) | `forward`\n",
+    "| `Transform` | `()` | `encodes`\n",
+    "| `Transform` | `decode()` | `decodes`\n",
+    "| `Transform` | `setup()` | `setups`\n",
+    "|======\n",
+    "```\n",
+    "\n",
+    "So, for instance, you would never call `setups` directly, but instead would call `setups`. The reason for this is that `setup` does some work before and after calling `setups` for you. To learn more about `Transform`s and how you can use them to have different behavior depending on the type of the input, be sure to check the tutorials in the fastai docs."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Pipeline"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To compose several transforms together, fastai provides `Pipeline`. We define a `Pipeline` by passing it a list of `Transform`s; it will then compose the transforms inside it. When you call a `Pipeline` on an object, it will automatically call the transforms inside, in order:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "tensor([   2,    8,   76,   10,   23, 3112,   23,   34, 3113,   33,   10,    8, 4477,   22,   88,   32,   10,   27,   42,   14])"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "tfms = Pipeline([tok, num])\n",
+    "t = tfms(txts[0]); t[:20]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "And you can call decode on the result of your encoding, to get back something you can display and analyze:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'xxbos xxmaj well , \" cube \" ( 1997 ) , xxmaj vincenzo \\'s first movie , was one of the most interesti'"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "tfms.decode(t)[:100]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The only part that doesn't work the same way as in `Transform` is the setup. To properly setup a `Pipeline` of `Transform`s on some data, you need to use a `TfmdLists`."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## TfmdLists and Datasets: Transformed collections"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Your data is usually a set of raw items (like filenames, or rows in a dataframe) to which you want to apply a succession of transformations. We just saw that the succession of transformations was represented by a `Pipeline` in fastai. The class that groups together this pipeline with your raw items is called `TfmdLists`."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### TfmdLists"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here is the short way of doing the transformation we saw in the previous section:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tls = TfmdLists(files, [Tokenizer.from_folder(path), Numericalize])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "At initialization, the `TfmdLists` will automatically call the setup method of each transform in order, providing them not with the raw items but the items transformed by all the previous `Transform`s in order. We can get the result of our pipeline on any raw element just by indexing into the `TfmdLists`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "tensor([    2,     8,    91,    11,    22,  5793,    22,    37,  4910,    34,    11,     8, 13042,    23,   107,    30,    11,    25,    44,    14])"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "t = tls[0]; t[:20]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "And the `TfmdLists` knows how to decode for showing purposing:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'xxbos xxmaj well , \" cube \" ( 1997 ) , xxmaj vincenzo \\'s first movie , was one of the most interesti'"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "tls.decode(t)[:100]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In fact, it even has a `show` method:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "xxbos xxmaj well , \" cube \" ( 1997 ) , xxmaj vincenzo 's first movie , was one of the most interesting and tricky ideas that xxmaj i 've ever seen when talking about movies . xxmaj they had just one scenery , a bunch of actors and a plot . xxmaj so , what made it so special were all the effective direction , great dialogs and a bizarre condition that characters had to deal like rats in a labyrinth . xxmaj his second movie , \" cypher \" ( 2002 ) , was all about its story , but it was n't so good as \" cube \" but here are the characters being tested like rats again . \n",
+      "\n",
+      " \" nothing \" is something very interesting and gets xxmaj vincenzo coming back to his ' cube days ' , locking the characters once again in a very different space with no time once more playing with the characters like playing with rats in an experience room . xxmaj but instead of a thriller sci - fi ( even some of the promotional teasers and trailers erroneous seemed like that ) , \" nothing \" is a loose and light comedy that for sure can be called a modern satire about our society and also about the intolerant world we 're living . xxmaj once again xxmaj xxunk amaze us with a great idea into a so small kind of thing . 2 actors and a blinding white scenario , that 's all you got most part of time and you do n't need more than that . xxmaj while \" cube \" is a claustrophobic experience and \" cypher \" confusing , \" nothing \" is completely the opposite but at the same time also desperate . \n",
+      "\n",
+      " xxmaj this movie proves once again that a smart idea means much more than just a millionaire budget . xxmaj of course that the movie fails sometimes , but its prime idea means a lot and offsets any flaws . xxmaj there 's nothing more to be said about this movie because everything is a brilliant surprise and a totally different experience that i had in movies since \" cube \" .\n"
+     ]
+    }
+   ],
+   "source": [
+    "tls.show(t)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The `TfmdLists` is named with an \"s\" because it can handle a training and validation set with a splits argument. You just need to pass the indices of which elemets are in the training set, and which are in the validation set:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cut = int(len(files)*0.8)\n",
+    "splits = [list(range(cut)), list(range(cut,len(files)))]\n",
+    "tls = TfmdLists(files, [Tokenizer.from_folder(path), Numericalize], splits=splits)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You can then access them through the `train` and `valid` attribute:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "tensor([    2,     8,    20,    30,    87,   510,  1570,    12,   408,   379,  4196,    10,     8,    20,    30,    16,    13, 12216,   202,   509])"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "tls.valid[0][:20]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "If you have manually written a `Transform` that returns your whole data (input and target) from the raw items you had, then `TfmdLists` is the class you need. You can directly convert it to a `DataLoaders` object with the `dataloaders` method. This is what we will do in our Siamese example further in this chapter.\n",
+    "\n",
+    "In general though, you have two (or more) parallel pipelines of transforms: one for processing your raw items into inputs and one to process your raw items into targets. For instance, here, the pipeline we defined only processes the input. If we want to do text classification, we have to process the labels as well. \n",
+    "\n",
+    "Here we need to do two things: first take the label name from the parent folder. There is a function `parent_label` for this:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(#50000) ['pos','pos','pos','pos','pos','pos','pos','pos','pos','pos'...]"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "lbls = files.map(parent_label)\n",
+    "lbls"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Then we need a `Transform` that will grab the unique items and build a vocab with it during setup, then will transform the string labels into integers when called. fastai provides this transform, it's called `Categorize`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "((#2) ['neg','pos'], TensorCategory(1))"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "cat = Categorize()\n",
+    "cat.setup(lbls)\n",
+    "cat.vocab, cat(lbls[0])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To do the whole setup automatically on our list of files, we can create a `TfmdLists` as before:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "TensorCategory(1)"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "tls_y = TfmdLists(files, [parent_label, Categorize()])\n",
+    "tls_y[0]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "But then we end up with two separate objects for our inputs and targets, which is not what we want. This is where `Datasets` comes to the rescue."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Datasets"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`Datasets` will apply two (or more) pipelines in parallel to the same raw object and build a tuple with the result. Like `TfmdLists`, it will automatically do the setup for us, and when we index into a `Datasets`, it will return us a tuple with the results of each pipeline:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x_tfms = [Tokenizer.from_folder(path), Numericalize]\n",
+    "y_tfms = [parent_label, Categorize()]\n",
+    "dsets = Datasets(files, [x_tfms, y_tfms])\n",
+    "x,y = dsets[0]\n",
+    "x[:20],y"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Like a `TfmdLists`, we can pass along `splits` to a `Datasets` to split our data between training and validation:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(tensor([    2,     8,    20,    30,    87,   510,  1570,    12,   408,   379,  4196,    10,     8,    20,    30,    16,    13, 12216,   202,   509]),\n",
+       " TensorCategory(0))"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "x_tfms = [Tokenizer.from_folder(path), Numericalize]\n",
+    "y_tfms = [parent_label, Categorize()]\n",
+    "dsets = Datasets(files, [x_tfms, y_tfms], splits=splits)\n",
+    "x,y = dsets.valid[0]\n",
+    "x[:20],y"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "It can also decode any processed tuple or show it directly:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "('xxbos xxmaj this movie had horrible lighting and terrible camera movements . xxmaj this movie is a jumpy horror flick with no meaning at all . xxmaj the slashes are totally fake looking . xxmaj it looks like some 17 year - old idiot wrote this movie and a 10 year old kid shot it . xxmaj with the worst acting you can ever find . xxmaj people are tired of knives . xxmaj at least move on to guns or fire . xxmaj it has almost exact lines from \" when a xxmaj stranger xxmaj calls \" . xxmaj with gruesome killings , only crazy people would enjoy this movie . xxmaj it is obvious the writer does n\\'t have kids or even care for them . i mean at show some mercy . xxmaj just to sum it up , this movie is a \" b \" movie and it sucked . xxmaj just for your own sake , do n\\'t even think about wasting your time watching this crappy movie .',\n",
+       " 'neg')"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "t = dsets.valid[0]\n",
+    "dsets.decode(t)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The last step is to convert your `Datasets` object to a `DataLoaders`, which can be done with the `dataloaders` method. Here we need to pass along special arguments to take care of the padding problem (as we saw in the last chapter). This needs to happen just before we batch the elements, so we pass it to `before_batch`: "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dls = dsets.dataloaders(bs=64, before_batch=pad_input)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`dataloaders` directly calls `DataLoader` on each subset of our `Datasets`. fastai's `DataLoader` expands the PyTorch class of the same name and is responsible for collating the items from our datasets into batches. It has a lot of points of customization but the most important you should know are:\n",
+    "\n",
+    "- `after_item`: applied on each item after grabbing it inside the dataset. This is the equivalent of the `item_tfms` in `DataBlock`.\n",
+    "- `before_batch`: applied on the list of items before they are collated. This is the ideal place to pad items to the same size.\n",
+    "- `after_batch`: applied on the batch as a whole after its construction. This is the equivalent of the `batch_tfms` in `DataBlock`."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As a conclusion, here is the full code necessary to prepare the data for text classification:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tfms = [[Tokenizer.from_folder(path), Numericalize], [parent_label, Categorize]]\n",
+    "files = get_text_files(path, folders = ['train', 'test'])\n",
+    "splits = GrandparentSplitter(valid_name='test')(files)\n",
+    "dsets = Datasets(files, tfms, splits=splits)\n",
+    "dls = dsets.dataloaders(dl_type=SortedDL, before_batch=pad_input)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The two differences with what we had above is the use of `GrandParentSplitter` to split our training and validation data, and the `dl_type` argument. This is to tell `dataloaders` to use the `SortedDL` class of `DataLoader`, and not the usual one. This is the class that will handle the construction of batches by putting samples of roughly the same lengths into batches.\n",
+    "\n",
+    "This does the exact same thing as our `DataBlock` from above:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "path = untar_data(URLs.IMDB)\n",
+    "dls = DataBlock(\n",
+    "    blocks=(TextBlock.from_folder(path),CategoryBlock),\n",
+    "    get_y = parent_label,\n",
+    "    get_items=partial(get_text_files, folders=['train', 'test']),\n",
+    "    splitter=GrandparentSplitter(valid_name='test')\n",
+    ").dataloaders(path)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "...except that now, you know how to customize every single piece of it!\n",
+    "\n",
+    "Let's practice what we just learned on this mid-level API for data preprocessing on a computer vision example now, with a Siamese Model input pipeline."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Applying the mid-tier data API: SiamesePair"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "A Siamese model takes two images and has to determine if they are of the same classe or not. For this example, we will use the pets dataset again, and prepare the data for a model that will have to predict if two images of pets are of the same breed or not. We will explain here how to prepare the data for such a model, then we will train that model in <<chapter_arch_details>>."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Firs things first, let's get all the images in our dataset."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from fastai2.vision.all import *\n",
+    "path = untar_data(URLs.PETS)\n",
+    "files = get_image_files(path/\"images\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "If we didn't care about showing our objects at all, we could directly create one transform to completely preprocess that list of files. We will want to look at those images though, so we need to create a custom type. When you call the `show` method on a `TfmdLists` or a `Datasets` object, it will decode items until it reaches a type that contains a `show` method and use it to show the object. That `show` method gets passed a `ctx`, which could be a matplotlib axes for images, or the row of a dataframe for texts.\n",
+    "\n",
+    "Here we create a `SiameseImage` object that subclasses tuples and is inteneded to be contain three things: two images and a boolean to know if they are the same or not. We implement the `show` method that concatenates the two images with a black line in the middle. You can skip the part that is in the if test (which is to show the `SiameseImage` when the images are pillow images and not tensors), the important part is in the last three lines."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class SiameseImage(Tuple):\n",
+    "    def show(self, ctx=None, **kwargs): \n",
+    "        img1,img2,same_breed = self\n",
+    "        if not isinstance(img1, Tensor):\n",
+    "            if img2.size != img1.size: img2 = img2.resize(img1.size)\n",
+    "            t1,t2 = tensor(img1),tensor(img2)\n",
+    "            t1,t2 = t1.permute(2,0,1),t2.permute(2,0,1)\n",
+    "        else: t1,t2 = img1,img2\n",
+    "        line = t1.new_zeros(t1.shape[0], t1.shape[1], 10)\n",
+    "        return show_image(torch.cat([t1,line,t2], dim=2), \n",
+    "                          title=same_breed, ctx=ctx)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's then create a first `SiameseImage` and check our `show` method works:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAASUAAAB6CAYAAAD5yEXhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOy9abBl2VXn91tr73Pu8Kacs8asQSWVpKqShIRoCZWwEGISjRp344Y23e5AbjrCPRmD3SbcER3tiG5/dgcQgcM4gmgMNHQwBRjaCBkxWQEITUgqqaSqylJlZdaQw8s33OGcvffyh7XveS+zBqAMTUG8HSFlZb773jv3nN9ew3+tta+YGUfraB2to/VqWfoXfQFH62gdraN1eB0ZpaN1tI7Wq2odGaWjdbSO1qtqHRmlo3W0jtarah0ZpaN1tI7Wq2odGaWjdbSO1qtqHRmlo3W0jtarah0ZpaP1giUie4f+V0Rkfujv3/UXfX1H66/2kqPmyaP1cktEzgP/wMx+/WVeE80s/ae7qqP1V3kdRUpH60+9RORfi8hPi8hPicgu8HdF5P8UkX916DXvqwZt9fc7ROTnReR5EXlCRP7xX8ClH62/BOvIKB2tV7r+c+AngS3gp1/uhSISgF8G/gC4Hfh64H8Qka/7877Io/WXbx0ZpaP1StfvmNkvmVkxs/kf89p3AJtm9r+YWWdmXwL+D+A7//wv82j9ZVvxL/oCjtZf2vXUn+K1dwHnRGT70L8F4CN/pld0tP5KrCOjdLRe6bq5QrIPTA/9/ZZD//0U8EUze8Of+1Udrb/06yh9O1p/VuuTwLeIyHERuRX4Z4e+9lGgE5HvF5GxiAQReUhE3vYXc6lH69W8jozS0fqzWj8GPAI8CfxH4N+vvlDbBd4PfBVwHrgM/G/A5n/qizxar/511Kd0tI7W0XpVraNI6WgdraP1qlpHRuloHa2j9apaR0bpaB2to/WqWkdG6WgdraP1qlpHRuloHa2j9apaL9s8uSYTy3HBODSIFkIQQJEWWEIusLQAkggEoiQUIYiSVBEx2pJIGjlc5RMroALWkCyjBgEBE7ImtCgaAqYFKLTWkrWQLREskMWgGJiSrSAiAAQF/5IgmikIFENVSX0hqH9NA0BBaDAyIsKorfZZwnCdIQTMhCSZaEKfE+NRJPf+Pe24RVByzpj47/YfocTRmGYyZTJdR0Q4feasX4fB1rFjmApShCw9ljI5GX23YDydIKmQrLDYnxEk0o5HaFPvoQhmRp+WUARVkCLM9vaZbm5h6sP6uS8s+wV50WEmTKdTigqNKMvUI8UgKKoKuTDreiLCrJsTi6JRSF2mxEg322d35yopC2E0RtsRsye/hKU5jQa+eHlvuGdTUXIolZlECAGRAI3BElKGDmem1YDYjcwEycRSsNCSsoGUF2UmYojpC5ghGGaZpjSUYGRLUATU7xtZKBhmzkVQ/N9NEc2YyfC1gRn87wUjEDEyIQhNvJEZEUFV/WdIQQwsF0KjlJxpmgaNiqCUUvzn4r9PgtJMpsTRmMl0ndFoxNax48SgdOVGZoomulmHiFC6Jc107MykxGKxIISGEALNeERKiRCdndl8jya0RAGzysyxTYwMgHWFeVogqdD3mel0Shy1WMosc0JyeQEzIsJyOaexgARIXSZboe97dneugkWsadDxmNkTX8TSHFXlsef35KXszstGSjZONLGhK8YyGbMlLPrCfNeY9ZllSaS8IGVjWTqWSehN2E9GnzJqSg4NFEMM1AIqkWIBy0AphOwPXERIISNFsWCklLAiiASSZEIBK26QxMAEtLhxEHOwCoZpQACKYMXfd7ZCCYKhmBZyMgricAmgghTD8J+btBokUbIWvz6DJrS+gZpAjG7PzQwlIAYRwdSwkun7JaVPqBhtOwJzQ6Mls+g75vu7lBjRLCwzSAxMp1OCRDIGKAEowei6BfvzPSxEJuMxmgOp62lMiBYIonRpyXI+p9ExsYzQ7F+L2rB/7RJXLl8iGfRWyKVAdmMuqqRUmO9cpaBYX0AS1kYsQlsM9X+imy3ou8xaM6L0M6QY+Sa0bKSHmBFmS5h3+RAz/cDMvE8sk9AVBmasBHJofKNSUAtgOjAjZoRsJGRgRi28LDMhhAOHQTlkPCozKIJvVPP9SbY0MCMi5OSGbGAGPWDGhKT4z6zMgDMjAYJEQnPg7MwMM+dWYGAmdfkFzBgyMLO32KPECJ24UY6BtbW1gRlTIQBtG1kmZyaMxgMz0QKNCcRmYEYyAzMUf03JeWCm7zK9FUrOg+EVsYEZy2C939MVM2JlYGZv9xp9l1m3ODDT/TFtSC/bpzRqo+lqwwv+wANoEcqh12mAnLN7nhAwM3LORFFijCRLSDHWRiMCRhaj9OYPWyGaQP0dYu6Z/M1Xg6OFIB4VOT5QMu5FzT2YA6BYLmgMqJh7DzH8UUFPIZpgWjckgbZxTxUUkAYRIys0REyglIL1GZ0osYDogR1XEXfC9R7l4h6w6xaoKsfPnGJr8zjt5gbrm8ex1DPb36G/8Dhta+zHLTbP3sF0c4sYAhoC43bCsl/QzfbZ3t4mXb/GeOcSUFhKg2yeYnrydnIQxpMJMbaU3LP92OdJV5+l2zrN5m3nWF87Ri5LlrM59tQX6Hf32E+ZbtRw8v63kFOim+0znWyys7MNly+xvbvN8XsfJCFo6VnkJfPnn6fPRhxPafeu0VNYaoPMF4yCkIDz12bDPWmbwM3MaPBo7mZmVuxpvac5Z9oQUVVy7hEJTNsIlkHlBmaUghal+h03YoeYEa2vvYmZ1etelBkrQxQlImB6IzMEj5Abqc/fbmAmijuqUoo74hZCOXh/Ujd1ETxCKoWUnb+uW9CuTdjY2GBr8zijzS3WNrduYGakxt54ixN3vZa2bYkh0LQtTWhZ9gtm16+xtz+je/4Sa/MrmMBMx8SN40xP3k4hM1rfYKwtnTkz/c4V+rXjbN52js2NY/Rpye61qzTPfZl+d48rqUNHY8688e0s9nZJ/ZJ2NGG2tw+XL3Ft/zon7n6APncEURZ5yfWnvow0Y+J4Sphfp+REDhPybI9REBbFeGp79pKR0ssbpaa1QnZrXp++qGEl+E6kpizVOIg6iCNxb7V6uNkEsUzRwLEmkOiw5K+nOEiZg59Xgkcu7sn9T7VQf0+gWI8JkP3BGoL5haBSPKWRwDIbjTkIVqGXCJINQiQoqIJqpIme2oXQUEpi0fVYLqS+oDGysd4gEhAxVAQ1ZXe5RESYxsjurKPvOlCHPYqydeY4m6dPs7V5nM1jx+hTYeexT3NKM51lmh52Uw/3PsTGsdM8e+lpUr9gb/say6uXWV+fstYnehGWOdW0DfYFjt1yG5effJolmVvvuItQOq5evEgBln1i/dhxJiePs//ssywWCyx5xCgGqNBlT0kLRgnQ1JQirzaOCUGNKOrBvQLFPXik0ObCaCR0+Uaj1DQNZitmAlD+WGYQoRFuYCYVEMtYiGxGpUiPJXVjlgFRSjVzZp6KHmZGcaezSv9W6RL1KLoigo/vCdHDeISGLvVEUaiSQM4ZixBuYiZqQ4hGMSFqQ7bEbLFEDFJfGE3GjEeeLospJRhSjL0uISJEaVgul3TLJRL8njRxzObJNTZPn+b4idOsr6+zs7tPf/GLnNLsBrIzrqXC9C3vZqTKhSe+hARhb/sa3fPPsLa1yTQlOqDPmZwzuSj7AutnzrL91DPkNnD6zK2E0nHt0iWyGcs+cfzsWeL6GteffIpEwZI78lAgK5RihAJJDNSZSVYwu5EZl1MEFBQjxhuZ2Vtmnt5ZvDKj1IRoVEgBVgZqeNimK1oH4yHFIIYa8ibIhRhd7JnQEKaRtEw1BXMwpOoklj3NiiZudCrAEt2zYAqSKNlD6mVJ1eMJvRXaEMEKo6BgyrLvKny+H2IMQ+pnZCQ0jIK/vxCERTIsmW/OGq5WuYHxeMy4hUYVCUrXF7Z3ZjUUr9cqQikHGtd0fcod585x+eoVlsuOsuxpLdGo0ZshRWjEWIYAsSHt7VfDJ0SF3iCI0hTog+8mK4KFgHQZicEjs9TTxBFajCR58OjJeiJKLgfp7SqyK8EjilIKEpRUClp8kw7/L4pRUHSYvm2bhkYDljPHJoFry57ndxaHmTmINFbMmD8vpKCmlBUzKwNiYEFfkhnTDBJekpkchaY4MyKuI97ITBki60Wp8ZoJqTITzIhBKBkWOQ3XvmJmiK4sobFlFKhambFIhiRIJdOXglYeJCpt2zIdtygZDcLePDGbLW5ixje7p5TCeDrhjnPnuPjMJcyg358xCUKjRlf8/jVi9KN1Col+PkOL37sgntYqQlMgxTzoZRYCpUvEGMk50+f0AmYAMqlGcX5/U817a/xQ77tv+1QKweoeeQlmrGRGozEBQcw4Ngk8M1tyfW/5yoxSGxsTtbrRrDq6iFnGVBwmCRjZxeUKWrTgoqB4mE4utEEwDYzFWKIIBQtu1Mz8Z5fimyYUKBRCCAeGSQ1VKFndGJWycoJYUHqDeGhw3UoZvDtVfwDIAsFcpNeQmTYT2iYwaSJX9hfs90vIocKdKKiH5dJh0nBiLbCXCsuF60MAOQhYFUnFaC0MRpVgNKJE8dQ2kNHq4YsGKAGxHlVlaUawqmMMHqdgJiuFiULGsutuqzdk6l7NBIIEsERRkAqrid+HgnlEqoLlg2TKBLK5V8MCSHYBGSNUIdbUr2tC5ti4oc/KUlxcvTY7OAm3jY0bgT8BM4aCeZovNQ1XjBAFNXNBVgMjETpcD8rika3kBBIo5VCEfYgZpRrBQ8zknIn196Tgnj1iiIIVZ8Y3343MJIyIkEtBgzFtJoxHgVFwZva6BVJivY5MQQkiiGSiNkw3WubLnn6RKo9AKGTz6DBbprXgBlxcrB9X56SqRCkoxe+bQC5K0GoQJHg0hzts1UgpCTH1/6b3Z5yVgJECZDMUsASooChYIot5RoL/O8WN0mEb4bqa6yzZVsGvsjKHNzNDhnEwToxblllYSmHZZ67PuldmlGKMNlS2apXrsFYQ6qbxf/cbemCYVuGbAp7yiFQPh/rNMChmZDMPA4tXLWIIBGoEU/UAQq1YFKMvGSvuuQzFJFAs0ahv3p5CQCglUUQHUXdllIQDyw8wjoHxeMT1/bmLt1TvrQceUySQa5UimpCGDccQfRz8d70HQUEUFdcuBn3BchVac9U71PUrEwJWo78CGoYYRQFM3XMV1+UGlTl4ypiteKFAXnhdq8ec/abX96eYFarcOkR5q32jh+4ZgFZhd62NrAX3rRk4f/0gUloVAMCFf3B9JesLmYEqCB9iRgREFKkVL1Y1KvEKmr8xo7PsHvpmZtQI5gacEF3fyYWlFXISF/FdkcLINCpIva8iroWKhBuYWXFymJlp29C2Ddf350MU9mLM9OYGohF/JzevlXShVmo1UG5gxu+JO73VPat3zL+3QKw/O1ipjs6AQlS9gZleDM3+faaeyvdWCJWZzEoqeXFm/HorkWasTq/xqrDvz5uZKXjKtz5qmKofotWXwpM7rzBSWh8FixKq8JgGvcH9CIDnyavKBuoipBgH4mDxsuvKuGiAK8vsBkojVhwSyRlVwaqHHgWlDQGpJdo5mVKoepFAXnnjQEHJllACGhhKllajl8NQrW68FK+UHQB0oGutrtWsRhYiBDvY5If/XK3BO0iokVAhqEdIVvPv1coKIkbIMpT4gUFMpZaTi4mLqfjrTdSNDvnAe9nBplZTTHP162n4jVa1mhtE3CKI9h7aW60sid6Qeg3LvGpJrs+3ePTQxMA4FJ7Z6YeXrrXKipmSEml1r1RewMwq3Vo9k5dippPCfu9Gw9+ZYUkQKS/JTC6wlEQp0KgzkLMhJVcHY5RaOQ3RBj3LI3C7YYO+GDNmK73NwCJB8uDMcjWoUg7u95+EGTHfH1GUIkZboyUz+5MxUw6KPh411ejTvPVl+NohZoZonEiUA65enBlDNN/ADOoSAnAjNzcxoxl6cWYm0bi4/dJG6Y8/5K24JxVRIlTPihsLLydUUbB6tlL7M6px8gzNAfCQFgI1z00ZQRCMEoVcPIxRUVI2iqUDUUeK56vmoX2xQ+9J/MFYsSE/9yphHKqCpSSyBYKwSp6qsVdyzQMjQiaTbBWhlap3ej8Qxb2ZmiG1/FrMCOrRoAt+q9IpVbz1+6IUonpc4PoKFDXkhmpQ9YSqNEBXw+yiQjAhG1hILuwbg2hNgajConi6EoqrNtnqddfCt0e5tQeHgJnWa/I0OhcwyVXz8e8rpeoFRemlEGsVLSP0vbG3vNGpObw1+tLKDIVg9gJm/D5WZqpEqfVemxQKHllFEQL+gmzmxISC6YqZgkp4SWYy3tagxiBge/VVsWLkbIRgw7OykgkhDMwoVg2oc+wC/aG0TjqSiTsgMiJglgmqNdow32gCQeRlmPFUX8RoKjNN1f5WWo41zsyqQq14tLvquUq+OSmmNKLODM4MtW/vMDN9NZTOjJG5mRmhrIoF2nqlWsQjulW/lcoNzOSajkhRMoVQ3GkcMHO4DvvC9bJGaRUV+c07sIZu3a1eoLoAKB4qCwUEGvOqTZKCFiFqcJjqDXTre1CiDeJikhV18S+ufnfwNMeCV0lWVToRSn3AEbeAWQAzcqq6RAyYJUL9NlEnIwCo1VRCEBVW3Y9qwR+S+e8ulOF7Q+1XOgy2UsPdWpUr5rD5DtP6e/z3irhQbrUvStQfep9LBcE1KcVYYoSgqPnDLrIykArZ0OpNG4Gu3sdGHUYPpz1iDLK6z/6/RCCVQqNLhOi9YlXoXkUEnkJW412Nr5m7j75qCSV7f8+q3L5aWiOgw8yslq1EU2RgJpeCimEYjSkJq6mxpzGyMplqNzATxTn5kzBjxaNdj8r8+1Vcil2l8zkZsVHUMknd2KyeuzPvxq9ZVZakIJW7FTNqTpebU/+alIMIYhDQDzHjmXNwZjT4z1ZnYMVXDHLAjHsi+lzq76a2SJj3StWITlVqddIQcWZEhFJfm2V1H2yIfF6cGSPhxYtGeteNrBDVOfKi0U3MRKoALiQReoxUAwar/Vsvt17WKIUQiPSUUmhNsSyMTTkWO0bthJPjxMZkzPqkMB5F0rJHCVjTsN0lFvPCczt77KSW3WQsFUJsMO0qdNXr4BEHhNV+H1IqwRsdsxRGIZBzwaSK6CZY9SAiXo4s5savlIKaf88KwhqB+u2rubqKYas/qweUqoEBSA1Do3nIL+pVjlWLhMMJSHRjlg1TdZFWjFb8+qNCE0PtpjXcUgWSFRdfxT2Yl+m911yl2rUolCIuahagdqGvQJ2EZujvsmzkxoX8iBFjFS6LpyYGxEY9mDEguLFEAyoJNU+PKELQgElf44FCNNeASoYcoCtGvsnwKEqIXogYE8gJNgishSWjdsKta8KoDaxPCm0olCz0fU873WC7S+zu9lybzbk8V+Yh0lsmtoJluYGZTKmR5U3MKDWSOGAm1Q0cViludRJZIKhVoyaklGiDMlI3LBFnxlCKZTc0UJlxo2bm1aZQU3yrGpUJRFOyrpzuizPjjDkzboiglYNGSA1GrE78MDMrB4sKTWXGU15DoyFBqiOJ9ObMKEIJ9T7WVO4wMyVDEKOJVfc9xIyt0h/qvlwxYzXaNy+WBA1ISaCeIkavuBBNyMHoig2R1ysySv/0Hevcdq7l9ju3mKyNma6NIe0w2bod6TpGbUMqSyR0UIzlfMFoMkalYUli+/pztM05Zl3D9tUdvvTILr/7iT1+88JKxDzI0YNpDY1dTFV3VFi12k3VOzR6s9uqqiRlFZAYJQhkw/eJ1wMGLUuFXAwNgkjEsjE0+ksh5OAep6YUZl5FQITiwR9NCIO3ZjBo1fKbaxxSNVZT7+QVSTQaarQEEiDWfD0XoxH3Ji0e4ppZhcyvWVWxnNwYWKmgVTBq1JasDEZcawHBCx+HhUi/qVrvmdT3tvLesVZNssI4K30AseKbTjzNCNUJuPBaaNXf/146gOz737fJyTMNt9+5xfrWhNFoRJQ5zfQM0nVEiVjokNCRuzmpBxNlOlljScJYMp/1zDvhwpM7XLow5+c+usPnL9/ITFu9d1lpGytmbBVtchCR4ymfrALi4qmSVGZSfZ8I5Czoqp1ArTLjjZGHmVEKoayY8aiuSPEIq2YTq6pxqMbtMDNaPMIo0iMhQHFjp9IgkgiiBFGivZCZsIr01A1HUmfGKjNS9SkzJdXnL/UGeWNrGfSv1d5YRVwZN9JWo7g8RF/eTGXmr8dqtVuMJFQn5sx4hlXbHoY9dyMzr9goff37byP1S06c3aR0GZVCCWNinqNtQ04Los6wMqLrZwQSfZoTY4NkYdxOyNoQy4wY4Ozpwlc9EPnIBcMs+aiIKByaFfIHJ4cEZRcJJZc6wqSUVWiN5+guwHvIGIPS1xK5GnSlp2ka1sctt617JLWbe7b3lD4taqgdKRR/sMEtPlCFPaMEI+BVDdcJelTD4GElZH9tNZAEhzJWw4R5mNtIrIK1eyXXuiCaVziCGRq0hsrewCdqfn1mPqlngkSPXEwKkgWVQCYRxT0mIu7FHXvfiWrEWkFMChMa+gpQKQVT96WNAW0gFC8S5Gr8shkg5ARJEtElYormG5h519ccx0w4cXYTSw4pCFqZKWmPSI+VEcmMQMZ06uXxLCz6Dgstocw5fnxCWe7zrteNeeTyErMEWgFPGat6y6pj+iWZ0UAxo+SqvQg3MBOCVvFc6UlYb4zbCdORctu6YUR2UseTzy6Yjrxp0x2VG4McpW7WmiapUdRT21g72s0KKs2BaBxd8FeTGgB5g3AQZ6YNSl8SFg/aOnJevVdvWiwCIUBbHXZUr4wdVA896kr5ZmZCrZymqjTpDcx4G4Xf0LZKOB4oeAQoat4dr17BbXIhtLU1wcSNmlplxvvxenqihBdl5k9llPpuGw2Bbrb0ob7SIxrBekQi2YR+PkdIxImSbETuoe+vMF7fIDLB+rl77hiQorQaiCxcNKwbverkiNYu3VWPg/hmWAl9WvtrIhxUOsRz5pW3dI1JsCj0xRCJLLuev/OBN7L39EUohcn4OKdONzz43r/JD//oL/DIpx9HQwFp/VqDDToFwRhRBWr1GSuxtoawVkulgRA9ugkiPvujwdOxoF4kUGDl8bIS20xfZQQjMyG6bmHeKOgpZx1xaKrIaS6Ap+xlYa+QeMdtF4JrFUCqUc2IWoqvWlyu7RwqVZPAu3NXDYIurhRWM1cm7hWLePVk5ZVHhKGp7qAhy1dQI1tPN1tSzBjFAIeYEY0s5jsIiTBWsjmC8/mKmRHWL8k5obFBiqIpEclVaFbXDavjWjEjq9QJhvnIFTOleAST1aOllYFdLUPdLYXq3SWyvhZ4/3tfw97TFzm+0bJYBt7wt85x9qF38sM/+gt84TNPgvQgLaE2a67GsAi1qGP4Aw6GWBiir1XvXIhKIRxiJrrzCN4KMW0jirk2mpXQJBIQotCu+okAK96zBSAUGpTc+vszgxhuZoaBGalsJ/OK+ajK4j607p34RQuiMhSRMB/YttrKo9WxsWImGCkommEksKQwkVDTSIY0+BUZpdJ3jOIGeTkj5IZFMcbTCUaHyhgJHXGyjhYjd/tYhqYdUWwNlREiCyiR2DaE5Z6HlgJSEhZleDgrTahY7Weq+6PW/Va6ogfhtbdmNV0dal4somTxCpr3PmVEfNL7dXfdymc/+zRvOTdlMm45u17Y3Z1x+Q8+xA/8i+/jIx/6MD/1736VoJlSPalPigPFxcGAITlQQqaRSCbT1JkHoXVDZrlO3zcUXISOYpSVqEpESkJjAWtZK7XpUGqZW0DMxU6R2t9VU5BVr04wo1jvIXcxcqNo8SjKqq4gxdO8XLwjXKr21EkZqjAlgGZP2ZIVLHmY54POVC0FQqmtAtX+NKJIgCY7vK3caJQs9zShIS9njMdTFosF48kmJgtUxpgsB2bSfN9/X9vQiDNTSoISaRpjv+tQFUbjBikzLK6Gr11rXDFDjY6GK5GKvVVmxNPOlSh/UJrX2kxrgxGWEkh9YTJiYGajUe4+rew++RhhsccP/Ivv4x//1/+M1E0JmukQnyIoVtN3wYKgVghAQmgkksi0K2Zq2wS5MhC8U75YcnFeY02FIpSMxoKVyFp1vknd0XjksmIGICCqrm8d2uTFeneOViozuZ6RYV6EKgWzQC4eUa+mM/pQZXut+lhNIwZm8OZhyeZBA5AJdb/6mEojiklxh4oRV+0sr8goyZRUhNRn2imMxhMWO3tMp+ssbe7ds+Yqfzs5hoWMypiun9EHGLcNOQj9XsL6RGgDzbgQGk9HDo+AeBLlCr7pwQ0dGtIa8Q2Sam/KoHl6+3oRasuCgXnjmB+HkdHxmDtvmbDTKXedFMr0Nmb7z/L0Zy4wnfwID935ED8/mtGOtmgan32T7A1gI6BXRXIiKuRVpaJ4GV+1BfG5tFZ8BkpkFf+6J1fxyp2WgmiFUQpp1QhtNqQgVt9DMSMGr+oYnpZa8bRj1LbknLxVQAQJ9U9qJ715zwzZS+LFBInGCK+Q9rkjxOAd9cHL9iG61ytFKMHQvDo1oRBUMAtILlU/qBqSFLK1QDcwM1tkJpOW1GdimDMaj8ndLhrGLG1O07ZIKhQKo62tWvqPlNTRB2hjoGsjy6sL6JyZENMBM6wMphvXiGuINzMj4hFmKG5w1LUCpJj3TB1iRmofXttEKJA0s3Hydu483bPTKW+4V9lPZ7h88XEuVGb+u+/9dn7w3/572tEWmwbEmjoXj6w7keEUC28/MaS2NKi2NepLNCHWTm6Fkgji14N49dXM211UFYKRkuuuK4dVql7mzEAMwZ+butSQUyGLHDBjritqiC59JI/EgmUvuhS5gZlWjJi9S1xVkKC0QekGZnwSIwc/vWHlvLxiGQjJo9pVNQ8pmIxe1ii9bBzlkcISDYW9vX3S/h6Tych7gFTRGPx8FRKFDEXoyoIsiqqxnF8BFsTGiI13HB8+RiJUIVqplQbV+m/+ZzQ/Z8fMhpEOrTm21NB91fezanTzObbokRTCWrvGhQsXOLteuO91J3ni4pLL55/jrq/8Cu59/TnOX4v024/z33zw2zh5YkwqPd8DYQwAACAASURBVMGK5yuhx+gJlgi1sUyL1ZKr0gTfFI14idqkuJBcK1Ia3HKKeQldvMGb1blIGgMhKqK1olKjIxTalZGq5W9z+1L7Z/y1EpSG1TlCWkN/qZ4yDAOkTaz3NggxRmJoiVGRGJDgfTFSz8kJwZ9LCUJUodFIDEoMPjoR1ftbQgiE4hWWG5gJYWBmPjAzGZgJGgdmUsKbOM0GZiztQ03vY1NekpkIB8yIDsyoeXQIDMyYHjBi8AJmSoYQos9elsJau0bq5wMzj3ziIpfPP8dD3/CegZm1vS8PzLRBCVYY2QEzLdmZkVL7sG5mxpskURuYCaoDM4pQVsf6VGYMl0F8D+hQuV0x42mfrygBKxCivoCZVsPATGzDC5iJQQ6Y0ZYYI6GJhChIDGRkYCYEIQSIhQNmRAdmokavPKMDM1YOxpJebL1spNR1iXbkIySxHZOWnZ/h0rbk4Nse62jW1qAYi34P0Smj9Zb59euItmhvLLoZy505cdQw21+4XhDa2hHq0dLQsuEYsWowNFwfQdSjJqolPqQJiHlag9bB0lWPhxlL22dzY4NLlyGHHc5MlyzLBt1jVyhhwrkzIz7z8S9xz+sTD77mBH/4yac9hDVgNQxafO4oijc8KkafXaBuonhTZjWopQipDsRLDDTmEXrWjjxuWE8jshSHr6ya5wqdHYi2PqiqtPX9Sjw4daEU1wz67B3buYnEOpoAtVJCwDQxIgxjD0MEhiEh+u/IfdW+ojcQklxS0kSD1PHrunKhjkr5BAeG1nTq8EoJxgHMMu1oQlouWHZ7jJt1cli1IlRmLLDotgnNMUZTmF+/joYW7TNRYbG7JI4aFvvpBcz4vJbHS56KHfT1HPARau/Qqup20K1+mJlcDibdQ4Gl7XP+0QWXTtxBDjucumOD5V7Dc5/+DDLa4NyZEU88kzm79bQz88g2zPcwFSbmzHgkFmjN50AMc6GaFTOFoOEGZgJCDl5s6JNAWELbMs7xBcwEehbi4aHWgecYox/EJh5VSe0dNDOf6C/ZB4ZH0cV10YNKLgFpPMofBm8PMaPmIn2RBNo619mQesSMxI6G8AJmSskuH+D3W6PQvnxHwMsbpfFI6ZaFQE+cCNKus9zbA0mMpyOknRLDiLQsmM2hRAJLrC8s93cZjyd08yWp65BxYO/Le3zhqY42NJ6f1lRIdFW+98Yu74w4fDCXRz2IT5yvZr38gDXx0L0IXfHmtq72Mc0tE3LD+775vex++v9BlsdQHXH6zac4/9HPceoN93EtrLN21xk+/vk9jpUd3vMt38pv/cdfdVG3pKE7Xav4LlW7aFqph3wJTdMM0VEbvbu1FFhf2yBNRtx9Rnnnu/8aG7few3NP7fCLP/UzkHoQ6OsGa2v43tVZJlRRqWOOshoEEIooFguxbYnm71lqD1aSQFMyuapxWb107PfQl9qq6ucRiGqgpJ5GFWIklQw5In4+SJ0i9yNDxDIleyd1SdlD6Zv6lEYx0y2FQA+TiLTr5FnPfnuV8XSETk4h1jgzLCBHkB7rM8v9XUajEd2iZzZboOOWvad2+d0v5hcwY1I7kfH2He+X8hJ9GA4CcGa0Vq+ChTqOVFMt/P7FykxUIUsm54YH33wGW15FlscYTU6w+eZTPPbJL3D27i2uhXVO3Po8H/+4M7PeKrPU+IkF5KH/R8GPVKnJZtt68eWlmEkUjk+dmfe8fsQ9D7yV+9/8MJ/8w0f4xZ/6GTR1FIFOhSINLVBKIq2YofiJobWiV4ZikDMTaPy9VhlhlQYH8yGUUqu9Oojm1ddlvGPesrcvkMG869yaxo9HSS1+gqUguZA1HJyZVaugVufEVi2uL7VeNn3b3fXDtRY99J0gtiRMJuQ+gowRa7CyJI4U2siim9P1c2zZ0YwiXbek358zn/VcvWw8+pTw6UuRLlBPFaC2fvohoxQ3LqvZnJWa740l+aB5q9SoQDmIIDBacY8xtoYg0MQpr7/3FD/zY7/Eya2TzPdblhubdJcSd371V/OV7/17vP7eB3nT/fdw29lNSog88dnfYz6fsXnyFtoQaVU5NV73HpiojA3GBiPLTIMfARwxWg20GijaI/0M3Vzj7tsD3/DX7mDUL9h+5jqP/87PcuqM8K0f/C7aMEbqEberGbkYlRgaT41VkeDghZrkZvzY3VAb2zBvdIu1Aqb1JEjDq5CruUGf6PYGQhd96yCsKUkSJr4hVuJ+q+I9VrnUEZdayQp+JLKK6xA3adwALPvRwEzKzow1o4GZ0i8OmEFZdHP65fWBmdliTr8/Z7a/5PkrHY8+JTx2LQ/MUJkRsxdlJtQOiMPMiGmdC8s1Eg1e1q7MAIzN73vTHuP1955iMYsDM8/uzeguJd72te8fmBmPTwzMnDy1wXw+4/TxUwMz66eOoQJjgVERxuZD7StmKC56N9oMzCRtB2aYd2w/c53f+Q//68DMXAvSxCrOePo3DWFgRiQgoaFRG5ixqr8G1He7GW2jAzNerTyIpMWq+FOZGc63IlUd19O8m5mJ4YCZetABIkKjfiyQNwG/ODN/KqOk6tBqU1iWjlSUoJlmvaXve7quYznvmO09T5r3bGyOWfZw+flrXHl6h+evLLiwnXjqOePZa8Kz25lndntC8SjAhxnVQ8I6TLoac9AaH2lVMaUERLOfo1yn9bMVUukPGtUoqGRS6NncPMa3//3votmc8j/+ozezMGPz1iVXr14lBOHb/u738YmP/Sq33387e7LBPfec5uSZljObiW98z+v4hm96G/fc/1o21sfM+jlbW1tsahym+1dalw8DGym7LjItLW956zm+/qGT3H/vHVy9sM2JYw1vefibmO8Xtp98hFuOrbP+xgdZLnta9TJyVh8unkpEQuNDvSVhQbHoYrSqh/baBMZVqBaJaBBUAypuyBtx3WBI3XIdxKxNoLFAiH7+dNsDeNRUMD/NkdWLpQ6nZqwkjy+qNhQF4kq0P7T6NB+YWeQlqSiiaWCm7w+YyeyzsTlm0dvAzJUrPRe2E5cuT/jyhY5ntzOd6cCMNyPXYc/KDDAwA/gpDYSBmdoQ4edkVWZKZmAmaCGFntvvvpuvff97aDanvOa2EwMz8/mcEIT/7APfMTCzMbllYGa9LXzje17H2975wMBM98xltra2AI9mfDjcBmZEhJQ9+l4x8/63bg7MhI3IWx7+Jnau7w7MvPXrv53lsmcUlFHwY3cXwsBMVKB2U9OEygwDMyMRLCjFdGDG01lnJtQRqGL2AmYCQuN1kerUDh0TcxMzVmRgppTkh9jBSzLzpzJKV67usrsfmS0iRQNdyezMM13Xc31nydXnnuH6zjX2l8reMnNle8n2XLi6Y+z1LXuzEXlfEcmMI4zE6Ho/YiELjOrohmtGqXaN1uE/EyDVfLcgVUj3c5o9Uog+COC9HEOVQ4gIy+WSZy49xcNf825uO/cW3vyuN3DPHe/gtbffydl3vZP/6Xv+S775/V/HWnsb6ITx5Bhx/RbuuOMOxtOzLOOU7/ref850a41C5o43voa1zZb22BZr0xMs+47p1oSzx44xQpEmY5J4+9vv4mS7zpeen/HIH32G9/+D7+XO47dz8fwnefiv/xP+7996nMcf/32+429+gPVpSwhGbzA29UplqHNXupL/GVLc1eOKtYktVp3Nu5rT0IFuWpsxa5QDXsr3Hi7/Wu7zcMa2G9hUB09LTZGk6lMegWFKLkpvPizdp8Ju6ljmGxvhdneXAzMpN3Qlc31vPjCzXFwfmNnZhSvbS3bmDMzs7kfyvqK6YNIKI3HHtGLGZyrNo+XKzEpsP3ym12FmRHuPlkwJVucVa1oHfq5RRJjvLvnc5x/l4a95N9/8d94+MDNpNzn7rnfyy//h3x0wszEemLn39ecYT89y5oE3DcyMRiPueONrOHvHLUxOnmBtegKjH5hpLCFNptd+YOZKkoGZ0Txy8fwnOXf/WwZmZlceY33aopIJ+MhXEB2Y8c7tUA1heQEzUgsy4RAzZmVgxhSCyjBi1YiSa1HBrNBlZybU4oIzZ1XMlxdlpmD05s2ZK2bm+f+H0H3lcqCkjnbSMdvfYjQWimSuXs9sThv6suaf0KBjUkrk5Zw2jmmnSj83tCxojhuj0pJmM46vNaikWraGXhON1XDbIirFJ/3FxV8zbxIQFCkZgkcpqy4mnyI3snmz2arbNYQRQQsXvvAlvvE97+bXf/Lf8NBXfjXNicRnP/4oH/y2D/KOb30PW/e+gw///A/B8XMcH91HuPMB7r/3TXz+sx/l9OlTHB/v8/aHv5LLX/gsz+88yZ13TJhMJqxPz3Db697NufvezpULj/Jrv/QbPHv5GmfXI6958B4e+9Qf8fBX3Mmxcx/gd3/2R2jf+BWcu3OL3/vlH+SrHn4j86ef49GNL6IKfY6oJroitEXppJDMGBnkkAlFSaEgCeDQmVYoYrXJrY5IlAJa/AMKJBeW9JRUyAVS8m7e6/iQ7zBAKkJf/BNl/IMNAkv8ODghgAbMT4CjoH4Uhdd8Iccasx4cXXLl2cDGljOzv6+Mxy2hjQMzO7PMqNlEdUzf95RuRgjNwMzIZugkEBbC3lU4vtZgmijmh5olqcxgB8zYaoq/zmlRI+f6iS2WnQ/x4TSCGL0JyupDIYQYxiwX25zQEXfcfj+/9pM/wlsevJ/mROLO+x/gntP3cd8t97F179v48M//EB/78Kd5/3f8PcKdD3DX7fdx/kuf4t7X3EcMzsz1C+e5eO1J7jsW6G47yebGSe544/u44+43ceXCo/zCT3+I3dkutx4fD8yc2zrJ3V/3N/jdn/0R3vtP/hXbT/8Bj37yowMz7/vAd/Pjn/mXeCup1TOgvCUnmdFKoagRitJr9qNWLHsnthlFfShSQzVegp+dXpmJBot+Seq9MzsldwQ7uJheVNAa/ZSVQ0wZJN7AjEmVFxRyrrOotV+cHOn/GE3p5T9i6cSI0UZDYEIMATRRusLmmpFDTzOa0vc9cbGH2oLxdMs7vtOccassioJNiCXRRGPUFNYaY7evU+DUpiozOk2QYo2pBbGEedciagfHYwWR2hhZ9RJTYt1Y3vVcKP0uZmvcevIYb3rjrXRf+9Vce/55Htx8iLd+/7/hiUtPc/HpJ3j+mWeRtTfxhttPU8jcduZWrj91Ac0zLjz6RS6Gnoff+15+5dHPc24t8vR8nbNnz7C/d5nnvxy596FNLl+9xp0nlaZped3pLc4/fp43v/v9XHruKT73kV/nmbJg4yMf4pbb4LNfmLG5+yhn77qPi198hHa8RZpfJlokRKtjHx7S96UaW3VwfAjEKzjFoMs9ZtCnVEVej6xSPcA9IZC9KVNXoi7eYd6bwaJQpLA2GZFjQy5GSZn97BPgsWlYzHsKvR+h2vtpApTkR1EErWc+3RgprZ3eYDTJBCZIztB4p/Jam5yZZkqfM3GxxygkdLpGiJFF1zkzcQrWgM0YT4xRs0BTGgZJrTLjqduKmdVxuQmI3pphB31LSMBKV2f5vD8/CLUy5YJ43+8y4gT/1ff8fR54za2kp17LlWvOzK3veJAnLj7N7bfeOzDznm+5hxOnjnPbmVvZatf48hc+ysd/9yOsTRsefu97+dBP/BDn1iLbcprbj0/Y3tvm2SdG3P0GZ+Z1d27y7M6SrVE7MCP7u3ymMvPj//Kf8tWvmfL7569z917m7F338fu/9//Sjrfo+6vkCNOipOx6m6lQqF3Tipfe6ymnJXsPU0fGUqHr+5puKRTxjy4Tj4JXZ2WtyiNzK4xiYJkzZemV57XJiCw+S9pl7xZvohKCM0OoJ0D09YwoSQSrH7tmBy0zr8go2f4CXYtMN1p6EpPRFA1COx5RujnCgsnUj0DVssaiW6BtZG28yWy+w3hhmPbIomNtvWHjROBtt/f89pMOBFq8yiXiXNXPeRNTICJaXFmqpedGQDUidfjPqqcQMYI2taQOi9wQjo35nh/47/nsI7/P/vNPsWhex8Mf+CDPPfM8v/ITP8o3/MN/zjOPP85b3ngvv/1bv8JoNOGJX/oJ7rnldv76d/5DLl18lGvPPcPHPvwrnHrDvUxsxp1n38SVL36Cu+5/ANqGS499mnMPvo/cGaeunWc0Kdx68rXEjVN8/g9/h4fuu5W8m1m/cJ7nrhQeftcbuFYCV66f5/jpr+S3H/8w49GUWd6lZCESMCn02YXBXKCJteHRfKJeg1cCl30h1FZ/qV6LUlhKhFRY34jsd4b1ifVxoS+BEYG9nMmLwvoItrbWoUukRpntLAlrkc2Nhj4LadkTJ8qig61xIEsgpcxOB/65OkITox+/e3DwJG3p0SJMN1qSKON2RBxFYoyUbo6VfdZGDW1sCCEz318gJI6vbzGb77CeAn3pkSJMp8bGiZY7bgs8/dz+DcwQBUlSmbEKesTjOaE0hpbgZ1rVs7U97a1VQ7zR0EdBjC5PWJs2XLl2mc8+coWLF69im+d4+AMf5EO/+X/xud/4dV73j/7ngZnF9gU+/blP8MQv/QRvf+1b+Zpv+VtceOoL7Fx5lo99+Fc4fu5uRrlj8ZQSNpbcdfsDbJ48OzDzzJOXePB4w9pGZLx1F3HjFPe+4UGe332GvJvJ+TGeu1L4rr/xbXz5wpNcuX6ex556hqcef5xJHLPMhY7kneE4MwF3QrFqPV3JNzDTJS9W1HF+r8zlQlJnZjQudDlC37E2FvoSGBdhVjIsC2tjZWNjjdRlRo0w21mythYYNYG+M1LKxIlSijJpnJndPT8PXHKPBaWJEQ6NyPypjVI7Cixmu5w4ucZGU9hZLNgYTRjlBc04EyZrlGXjWoY9y8YESgTTzPr6Jmltyc7la6g2TNvIbWfhtVf2+Y0nehpRVIQ4CoTQEPEzhfxztaKr9d69SYgeDoZqhFpTUunRNiD1I2qCQmoiISWuzDLdPHF5+zrb58/zTPgq7lt/lk9/6lN89Dd/inkH587cwyef+CL3vubr2LnyOX7vt36Pv/2d303PlA/92s9xfOMU4+mYh977X7B5/DSXHv8cz3z2N2jGDYt+m3xlznJzxIljG9z22ofYe/YWHnj7V/HUo3/IbWeO8d9+/7/muauXSL/4q+ysT1nsXqC5cp0ShdtP3stsHLhWAuNlj5RAlxSxnlLPs26a4OcspUzTKItc2NwacenKkuPrLePolR3MmHeZUYhsHGu4dn2fjVuOAYmpZvZnhZQz62sNpU9sTDZIax1ZYTnvsGzEXticBhiNsNkSK97z0nV+dri0Stf1iAlNDJQitEH9o7PSjYDt720ztsiJk2sc34Cr2wvWJ1NCZUbHW1jXEhD6vX02ppB1AmHG+vomOWe6q88TwpiNcSCcVb7m3jk//kxfm/IC2vixu6H1yo+QEGluYEZrr00Qq5+NF/2Yjhi8W/0QM+TE9n7m8rPbhLUNts9/Bj11H2fbHT79qU+xvPRF5h387z/5g7zv7e/m3td8HT/2wz/Bct7xt7/zu7l46Qof+rWf45bjtyKtM9NMRmxfvIDoH3D23K2cf/qL7H7uIu2JMSeObfD2976fq09fpGlhNAncduYYzz39FA9+w7eTfvFXmW3B7vY2z3/sY4zXIrefvJf5+Ayf/uQfsShG3/dYaRhT2LNafMFPeZj2PTEGshVGkxFXd52ZRmAafVh3ngqjEFnbDFzfnbNxyzGsdJSlsTOHlHrW1zzd2xqNSf2cHIIzY0bsI5vTgIUGFl6oWjFTAgMzzdhgGUhkJo1/3Jqmly/BvaxRSt2cY8ePE+gR7TmxNmbUwGgc6zEN6+jGPsoaOZ8kpYT2c4JN2FvMCNE/mbXrEvu7CTU4e+sm73zdBh977BqjIBybNjSND2yiATs0uKjqljXnDL2nKKifzx0lEILVQ/PrIGDJkEB0TIyJz/7RJ3jojtt48v8j7c2DNTvr+87Ps5z9vNtde1/VrQ0hgZAAGTCbF8DLGDzEjkkxjqfsbBM7duyxM5kZnJlUUvHYnpqaSjKOt0rZMV6wwSCDwAKEBEhCG62lu7X03n277/6uZ3uW+eNcrgKxSY3n/fdWV1fd/vTznvN7vr/P98XnOXbXvRw7sZeHH055wzvv49yZr5FlKZ+9/w+YrV3izne8i3PnVzhw01Huecv3cvGll9DS0+kosrk9HJKOfG4fNy4/S3npMuvCEQaLyGjAXBbi0KyWFW9+1/s4f+5ltm5c5bnHHsZWq2zcWEXoAfH2FvHN38HUFTzz7HnCxhMoh7EQivaQTWPFbGzxzhIqAcowMxAi2d5siCOFt45BFjMelfT6KX48ox41rFlJ3gnRsWCy2WCsxChBkuco5wjThJlzrXJmUpFFIcaWNDisjhluTcgiRRyFrI5nGOfbv89bOkkMQAoMt2dU1uNNu6X+n38CpUnzHEVDXVTMZQlZ1CbXnXAIFxN0aiQZYd7D1EA1JPT9HWYcaZoyHhU7Sg3D/r093nwy4IlXtkgCQR5pgtDtKAG+mRmt2xR7YwzS7PiflG/FeL7dTRPfwoyrHULGBH0QVcPigX0sS8f8wnGOndjL+vUTvOGdx7jz7rdz5eKLfPb+P6Ce1Nz57paZEzfdxtGbb2Xz2hXqYkano1g+epKNNGfkxuxdPsL21XVmuUHsMHNs3wFK47nrNUfp9BY4f+5lNm3N5iMPYatVttcstR8gwop0/g6mrmCpH7fMeLtjU2sIIk0atsw43wZXwzCgLhtCISgm9lVm0pDJtKbbCfGzmnrUsC0ESd4yM1y3eN9u+Ce9lhkZRxSNJVIB5aSklyXUtG0/VsfMZiWh9iRSc2PWMpMmepcZaT0mF2xuOCrfMiO/0Sz813y+7U97YUY/rKCxRCIgEAZvoJpVBHaBphnim7k2WSsgVBlR1iXsJQwGGaacUc6mxIEm7WjiXLEwJ7h9b5ujkHJHVaoMQrX7YoEGhEHadsbhnHk1GNbO9ZEKnJZUhaMoYeIEw9qzWTRcLxxrlcE3CdPZNnEn4V333Msjj1/kxdOrfPCDP0mWzxMlPS6tbJDm80xKwWOf/BQ3XnqGpz73x5z6/CcIfcWll57h7NNfo6drOp0Oy3sGCCXpnTjGG9/1Q0yqVd70ju8lFJ5bTh5iQc545dwZlNY4FHJwjM9+6cu85yd+ibH0vOVDf5+/uP8zBL0litEI5wXGtod8rQOclKyPG9aNZeokk0awUQgmxmO0JAgFC1GIKRyzcUXazTF1g5YBnYN9pmXB1thw7fI2a1sltiqRjWW8OaYwFhdq4kSAdQy6EbV1NEKQZRm2qLDGMystW7MKIdsUcG1ha8uysjZhbTzjxmY7mJbCE8ch33q7uzCId5kZpAMCYXCN32XGmmKXmUBmhCojyed3mZluTylnU/I8pzsPca7oZsUuMyB32mDVLjORepUZ27SDWK3ELjN6J/xZK7BN3TJjeJWZmWetMqxfH/PUlx8n7iQ8+cyTu8w88rWnyPJ5Xj7z5C4zKgl2mXnu8Qc49flPMN26usuMqgWdTod3v/PDxGFC78Qxjr3ue3eZuXT6NLecPMRL517ZZWZhfnmXmXQ+Zyw9C8dP7jLz1c99YZcZGQhqHVBLtctMKRWTRnBjVDP1AqMlUvtdZsrCtMwYdpnZHr/KzGhYYasSGr/LjNSKOBEI45jrxdTWYbTfZaZoTMtM9SozZeN3mbm2OebG5gwpXmVGffsz6b+yZmIqpuOAWBbopl1sFbEgDQfoNCYK5vAyJFQBRjjs5CqmqambCi075P05UgymqkmMppw11LWh31XU3pL41lyn3U5PnG9nSxhJuRMOLGqFp6ExAikdjhp8sKNu1SglMLVHqxBjDEJKMp1SBYYkW+K5Z77O9c11bJlz00/dzp/8zq/z9vd8kF4/5kP3/RT/6p/9XYLNa+SLCwwyzaXNVWJfU/bnSPp7kCLizNlnUXbMbDRkMe0h+yGmLhBNwFe/8ClWblyjfPoLnLj7+zDVCKkE48kV3v8DH+D6Vz7Gw5/4deb3zfGJj/0O7/iu72FzZZsLX3uOMJKY2jKpDVkWMStqpJQcOTBgdX1GpCBGkmjN+nZNqAyjqiFJY4rSUG1MmHpPlirq9TFJJMhDRVMZkkRTO48wrr1tmtZc2iroRZpuL+G6sVjRlj0Otyf4GpJY0/hWoheqGK8NkW7nXN+o+yFwO3uOnkA7GhkAxS4zVWVxxhPLgq1ySpBFiI5A6y46jdFqAak1oQoozAbKzTBNRW1qtOywuC/DuAhbN9TD1uskMfS7mtpbclpmEjwehfWiDZXvMGO8RVT6m5gxrmkHrwiEiFCqdVMHQmKMIYoCvI/YNhPe9e638dwzX+bg0k288NJlbvqp27ntwpMsHzjMmWee50M/0TITTjbJejmDTHP9+kv045gascsMvuLKK0+iii+xMR4y2HeAs8+d2WXm4K138pXP/kcWjt5GIBOkEmytnOX9P/hTXP/Kx1hZXWf+0H5uf8PdjIoOmyvbrJ0/TxhJbGNQKiTTatdBf+TAgJUbY9JEEdg2IjObegLZMGpaZsZFTVA5SgdxJqnXx+SJItthpolEazRwrd21mdac32Em7cdsO48TFlV5RpOWmVQLGqFxfx0zO650LzxN2TJT8e1nSuojH/nIX/vDUx/9lY/4xhC27XskgyXyToaQnt7SnfjsFvSetxDPvRYdHqHRI5QG10AjCmSQABCFKXXZtBXSwlFbwaOnG0prQGhqB7NGYLBMrWRqoPEC6xQz4zEubGPwXjEt2uGcdJKirrGVR4WKqja4qj2UytBhXEDaiXnrvcexdcx7P/B9fOlPf4Ogv8hNR0/y3BNP8Id/+tuc3HcL4UAxG1c89tnHsRvryECwdeMippmQxSFLew6w58AJys1rXLz4GM0UptOS7asvooOEfbe+jte9/j7OPPcgS4P9rK6cJ1ARz7z0de686608fuoF7nnH+7jp5vuQ3vPwg49ybWsVqhaoZzthCwAAIABJREFUqgZlGzQQhYpqVOOrGhzkabuXFkEr/vIKa2wr8QoV3jYgoTHtzryQniCJEVKQCE2aBwRaE4UhaaRI4wBjHMo6AgM0Fd0wIA6gnJXEod5J97Z7UB5LFAcUhWlveFSbNwmjNkhqnGFUvZo7+cGjGmcsYaQIsoC4u0CcKKSE3tKdxIuvRcy/uWVGz2HCdrcQJ2hEgXUZUgm0jtneHOONQaiI2hgePd20w1sUlVXMGnaY0UxNe81fGags1E1rWHBeMalMK20wrY+rLi0yVNRVy0yYp0ypiKMMYyfc96ZbGc9mfNcPvI8v/elvkO27nUN7lnj0oT/hwYc/y8l9t6D1hKJ0PPbZxxnduEgYBmAqytk6WRyyuP8wvcEerl28yGTjMsWkohrPKLeuooOE173zu9m79wgXXnqWpbk9rK6cZ7tUvHTlDHfe9VYmxJy48w28fPpl5uf28PCDj7K+uUZTGQIlqWsBTU3tLGnQMiPqBhzMdUMwEElBqEQbITAW6YBA7iiOd5gR7Q1vkMQEUhJLTZQGBIEiCkOyWJNGmqa0BB4CA2ZW0UtD4oDWIKK/YY39K5jRCqegqg1hHOyYDQz/5Bf/+S//zQ6lP/6XHwkChwoMMpBoVRMkESrIsdFB/NxtHHv9j9I5cJKt7RWqjedhfB1jDUEokEpghcbaGkSDsDVa54xHNY+drZg1Cqkk0gk2a8NmaSgrQacTta8bvnVVC29xgUDWbfpW4BGBII5DGuOpa4NEEodtsZ/XKU1dcPqZM3zXu97E4MB+Hvvqg9x27CZkf5lzLz5HmEpqG3H2gU/QCxX/2+8+yqWuYf3KJkfzhMZMmN+zTJbF9OaWmVU1N65eIGhqTp85RRBK0t4yvcVDXL9ygfmFeQ4eu5v1oqSo4OzZx1g9f4nAC6bFDU7edS8vnbvAEw9/kWeffxHhFfP9Dr1+RC4lEw95J2Z7p64o7yY4CdorpAyItCBNIxLbkCYJeSdHm5I8CNECetKTqwAhJIH22Nq1FgBcC59v5y2jsm6FXaGkbGpUEGJVjTMBYQROeZIkQCYh0lsC5VudS+gJY43UijCUYD2VAq0ChtNql5n33xGgtUcFBh1pJCUyjAnClpn+8R9g+ebvonPgJJsrZ2hGl2A6wtqSIBQEicaisbYiThyYhrKqqUrBY2crpqZdVo60ZK1o2CzbxpEsDSmMRezsPwoJTrfMhKrVAupYIWTrmRrPLKEUxKGiNBXIhLKesXVjyJvedCeInKdPPcJtx26irKZcuPAKS/tei8Fz9oFP4EzK//EHX+VS1+CvGfbmGpMIBr2cLIvZf/AW1jbXyJI5Llx4iguvnIU0pD+3j97iIV449XX6/Q7j2iDyOYoKitllLj5/lsAL9gw0+b6DTOuURz//aZ59/kV0rOjlOYNujPSKAkcaKcbTNpbRyxOMgkAEKKUJlCSJQ1JnSJOEIE6IXEWiAgIh6ElPvLNSFOi28w6liCJFWe0sFYeaabGjupGCwtaEcYTZYSZIWud23kkQkUb69mZOa40LPYGSqFCTpCHOWCrV+rB+9n/8Z3/tofTt3+4UbX2yj4iDsJVTOY2SMdJW6HINa2uK4UYbJ6/qVngeSGoRoYMIU05wdY03DQ0hAgNKopSkm8JCFhJGijjUHFnu43yDDhxJFOJqizOWQAtC2zaUIjUyjWlkwPqoZOYl2VyGTyVD44kHOf2lBZI4o9PJOHd9yFPPnuX93/nDPPHyK+TC0mxe5pWnvsbVT32CA8eWcEnE3FzKrfeGzL33rejuYVzTJe8epJPvw3hDqCXHb38dF546Rb2yxvr5C9w4f4ZXXniMJO3w1KnThHmH6yuXEVqwf+/NHD1+F4UYc8vNb+Tphx8imV3n4UdfoZ4ZAtmqLuSkIYoD9nUSwspxII9YSALioiGXYIwh8w3WOaZlRZAnFE1NYQpUJ2XYNKACfB4zosEKg/etekIHrXguziVBLvG+oB95sp4mlJb+Yk6caMKwC6Fh2rSRgomDorF4JSkslNMS27TzGTurqCvbNo5Y/19oKGTod5kJhABvSaJ0l5nx5gu7zCTdJURVI8NylxlnFaac4Jua8XBCQ0hZ1LvMDDLNQhZS4neZwb3KjGjaWWQcyF1mptYj05hpI9goGmZesrwn3WWmN+jRX1qg35tjZWPMuetDSjfZZebG5oRm8zJ+trLLzOFb9+4ysxWF6O5hsqizy8ysnLZPELJg5etfp15ZY3L+yi4zYHjq1Gle97p37DIzHppdZlxnjqcffojR+pVdZuzQE3lLU9T0Usm+TkLuw11mUmPIJUy2x+QSrHMMZ+UuM5UtUZ2Uae12mZkJv8uMEhIdeKqq2GVGNS0zSa6IY0F/MSfq/GfM1L5lpja7zEwbt8tMqCV2VlGVZpeZb9Xd/H96Unrp07/6kSCLiDKJDkKwISiLjiIwa8SqZrJ2msna89jtU4RqhAssofY0owla50jlsGZKVTY04zHjJmR9s+aBZ2aUDgZ5yNxSj2Ri8cYzyCOU8NwYVcROUyWa0aQg7ESUlaXQ7dwpjxSFtXQC6GQa6WCumxMmHaIsws4alvYtMhmvMXnxLNcvv4DqzDMcF1TGsdwLmD+0hC2muNV1Bp0eo1fg733XW+ns77PvpjuQWBYPnWB7dZ255T2cP3OOU489zNVLN6jEdR54cJXji46bXnuCXAZcvn6ZC1fP4l1CHgUcO34T1XiNwZ79dCLB46cukBQTyllD48BXDb35hO2RwUhP3svYLgtII4gVs2lNnieUssFLR6AVyJqwn+JmM4xtWOikNKEn7CREUYLsRHQTSWMsVkWUXmBViLJQuFY019QG4QWNsRS1pakbNAItox33Tyv3CrwAYzCodqu+tjSRIokjAuURpt1CHM1eTXT/7Tfl6CQmyiRhFONNgJAOGQZg1tBMma4+z2TteYprf0kUWry2BN9gJk5REmwzYjax+HLGRKQMtw0PPDNrX2mzgHyQ0i3AG89CJwDfMqOUookCpqZEJyFlZamoUWjy0FNa6ITQzUKE9cx1c9K5RXQoGY9HLB3eSzXeYK92PPXYF1GdeT783/0TnnjqUS595RFO3vcabDFl8tLLzPXnGL0C/8PffQf9g3vZs/9mvG1YPHQC40riJOfph/6cjaszzr9ynnDPBT71yU2OLzre8Z734WZjDp24h4e/+nG8SwjKKbff9Xqq8RqLe4+TyIqrpx/HTw3lrMEphysN8XyH6bigFpB1ErarlplGa4pZRdKNqKXFSdv2xqmGsJ/SNAW+aej1U6xumZE6IOgmdBPJpKwhiJl6j1cRykJl2oxTWTetMM46TOGomrplxrdL5dIrAmEJvEC6dvziEFRNjQs1SajRCoRpw4Q/8/N//ZPSt69YCiRSWYJQYUxNmnXaIklXIGTOZHidkBkSgzcllWtofI2zY+IkoXFTqBu8U9jSMpooKj9jY81TAH0tiOOYZrvAe0ekQgihCgJSKoIQdF2TJxGjYUMn0lTW0YmhKRoGqcYVnmpYM208s+kWR+44gM8icgR3v/5e8rjg8qnHifYu8sZ7Xs8WC4zXzrF1+RSB2ULGIXWvwz3f8TbuLS9yo9rkpuNvpjfokHcWMJVnOjvLsJywfPAgr3nv+/mN37mfO2/N2frCGa5vBTz/qU/wgZ/9F2wVNVfPX2C2uYHJ4dkHT3Hz4YMsLMxRN2Ne86Z3c+nsBTamBUkSoQYhMw953A5j8Zr5fkaQhFjX0OmmTMZTQjQlFpFl7aurh7DfxxUVG02Na3YOEqmoxgU2jogcWFsSAaIBnCXeEXMFoi0mcI1HC43SrTBPaEEUxDQ7z892Wu8sIAvKssIFCl15JlU72A60QJlv/taTUnwTM3GSte6eHWZcvYlxIyQGVENVlhhfIneYQZbYuqFpFIGVrE0UzDwba44C6EWaOI4pRwa9w4zWkkopUipyJWnqGu8E0x1mpAvpRw6cJNcGZSXbqxMaFLPpFnfcfjujpuSQDrj53jfQZQrSEO31vPGe1/PQX36Muf03MWeGFEXLzCjucM873s295UXWx4KTd9zK3gP7kTLEVJ6V88/SPxZw/I438/zLG7ysDtDrX2drYri+FfCp3/41fuSnf5ntZoPMp8w2Nzh84gCffvCT3Hz4IF54gk6HiT6IC7fZmBYMuhGqF+KriigA5yuEDHaZqaqG3mCe8WgCtGF3nXV2mcmTLrZpGE2qnYr3VlpYzZqWGSmwTUkmBDQNOEsiBV5IsjBC1rZlTbdlpkJKwqydLbqgHbrbaY2OFEHdUJYVVkioPGPTgHUEWiDt/49Edymgo9rlPaUUXlb4JkJUBZU3hKILVbMjk2rQNG27lPdYP6OZWqxwTMZj1rcLaiUZbwnOrhR0lEAHKSubE2bGM0g0480RYSdiVo/IrAfZtp3GiWZa10yMo+8M4zomD9pgb2ErAhQT4+l3A6688grdfQd4/Vu+g6MH9vDx3/4dbjqaML90nEBGvOV1t/PQ/V9GVFOev+TocYOf/r8/z1ce+lMy0eM1d72BRx99lHo2YeTPcnFtjVylXH3mIeaXb2N5qU+uC5789Aznp8yF66yebXj6K19g8fXfx+rmNgePLGKLhre9/j5OP/sYm1mXaOk408vPM5dovBKEeZc81wRRiI0j7HTC9mSGtIrBjpNoMisIc009LUELmq0hlQgIHTTCopQgsBKtNNK1XqZBmGLqVgcsgoAwbJPxjXc0Mwu4NgCHw4QBHgWNIUpDpJSMt0ekWcZke4qOA2oHtTCEsULWDgvEOkQJh4jAugA2X719s1ITKLej8/V4WVHVFYGGyhvcRBAlrd0A79C+lf4JdpgZOhpvmU4mTGtJreD6tOTsSk1HCYxXrGxOUI1CpzDeHBGViqm1ZNajhaPxnkEcUc4aJsahRcm4Tsm9IlKGuml/d5OmZebZrz3D3IF9/MB/+6NMihEP/9EDRIMB73vPfQQyYtJsk/sbjHXIubMtMz/1b/6Ip772JTLRY9+JO3jx2adxzQRVj7i4tsaehQNcfeYhjr3hvbzpO9/C08+e4YufXMD5V5gL1/ErNU9/5QuMO0d2mfFEu8wcPXCQqH+c9eKxXWZEHpPnKToOqIZTrJNsjQqkEwy0pSkko+EYnUrcrIZAUG+MqJQmdLTL36LVNkvpkU4QSkUaBi0zUUQjJHHc2rsb7yi2S4JQU0wrgiCgCXW7feE8URpiAkG1MSaKAopJg44DJkUJgSeMFUElqTFoK4gCjYjap6+/8aE0HBYoERImemdXRuNEw2zq0L7BqAZX5BjnSXRISYrwE4pGYJoaGsFwq31VaVzCtauOSSn49OlNup2crnKEWczBJKRSjmujGfGkRCpPNpexPizQPiAKFZ0kJooEiQ5ZjC22aYXVVgmcluQzy6RwkGr2Hz6CqQsefupZhj5lfvEm9p+8jaTfZzA4QKZCmA+4uXeI3rEP8PE//re89d67GY1mfPpPfpdBdy8+Mrxw5imWlw+zsBhy7dpVIp9j0nl+9V//HA9+8SsMXz6FdiX77lrmbT/2s5x94hG++53vpTQTrl2/Sm8+JslDGrb52B/9MVG6yCgbkOkVYjNjuFqTpgnGCVQQkkmJCAXNGIJA0A3DtqIn6yAjxeRGgUwDoixA5zHF+hDjDNFcRrM5IYoCpt5TzQxoRegrklAzvjFFyQYfKqSVSAkpgqCTcGNjiMoiRCih9kgVMJwWeN3u+SZ5QmQszteIOCbV0FSW8aTBOYGS3/ytV5gaV0jCpL2CD9CYumLmS7RvIJKURdCG7KI+pU2QYotp1TJTjGrqUlAZyfp2w8Z6wMow5dOnr7TMaE+Yx/TSiEJaro1m7fL3DjPXt2cEhKhuRMcrokgQJwmRai0BTSFxoaGWgkHpmBQOOZey//ARbqxc4OKFKwx9yve/9cQuM28+cQfnHvljTl+5xs13vIbesQ9w5uvPcPOR/YxGM84+dD9CZ5jJBmdfeYXl5cOMN67TjNa48MwjlLOKX/3XP8df/MWDlNdCtCuxYcbbfuxn+fP/+Fu7zMyKhl5PkuQhr1w+xRefWOXM40+z7/hJMr1CUBuGq+tk3bQNNOqE2Bp02jKThhAQIqwjnBsghGe02hpfoywgHORMVzZohCPupTSbE1QaUhhHNTPtnxUFthNRXBmhZNNellRtrXlga7r9PmurI3Q3RIQSP6mRKmC7bFA7zPTn8zYv5mukt3Q7KcW4pKgtzgmy/0pQ6dvOlB75T//mI1E3xglPUxsIBd5WeA1N4WmcAwwygAYJzRoOwXQ8o6orhuMC40JmZcNw01LUIQ88vsHmTOAbi1KSrJMwnUyIdcChQYfAeOZ6MZlTpErTU46FJGNzY4tEa7a2JxAmlNslYRYyMTWTiaGzlFEbR2exx+ZoQphEXHr5PGk34MjxeY4cPMapU4+S5h02Lp+l3GiYdLosqor3/51/ipSeT/zKP2DrlcsM9uRcfvk0n3voaepqhY2NNYJqwrNf/goqXiM78j7iZpPuvjspNq4gteWF0+c4cnAv3eX9bKytURcjvJ1x6tRZ7Og6L694HvjEZ1i/uE04UARxzNJSDxFGqFAiTNkWH2pJIiRRJ8PXNdF8SjQfs3Z1Qj6f0tvbp64N5fqIzlyPxta4WU202EemIVsX1rDCoqQiT1OyjqbC48oGS8RUQFWZtgt+WhIHmmA+b31EoWI2mZHmCYH0WOcwxpHEAk2E8BYRa3SmCZTGFm2N88bs1du3774tQ8UhTvj2pl/79vV+hxkrKry1yACKpkbYdYrKU85KqrpiMjFYH1BUhmKsmdWKjz+xRVF4fGPbW888YTabEKmWmUwG9PKAzCkSPL0AYpUw3WqZKSYGq0IiDwSKcVNhK0G6kFAbRzzI2B5N2BoPKcsaHTn+m/d+kFA5Tp16FDMbYafbKLNJ1dvHoqpYPHKcPfsO8Ylf+QeMLzxLttDn6a88xpeffJG6WiFoatx0m7OPPcKJe+/G5K8lkdfo7b2HYuMKc4MBp547zeL+wxw8fpSNtTUGWcLW9lVOnTqLKWsurtRMxg0vPXOJcKDo5h0G8x3iKCESEmfLVninWmbi5TncdEa82CHuhaxendDfk9NZ6rVbFZfW6C7OYUy1y0zdGMbXtrHCEuYBiY5YXMiZ1jWubCidppSScdnQS2LMaEa6d4BOAxQeoxRVUZCmMaFqh+vWQhzRMhOBCDVRLyaQLTNWwD/++V/6m82UZiZhPHIYZ4mjFD+rmYmImAhnK4KZx8UJZlRgzBRXSpJuiKGhaCRFJTGFYjwUnLtgOXdjyptvSji1PsUaQ2VDZptjOr2UclJSCUFnoJmOHd2TS6w8+wp7FgZUkWfh5kNsXFgl72fo1BFrhbEVWU/R3dODcUXWgeFozLE33Mrli5f5R//oH3MsmzC0GTcfO8j1Ky9y7cJ5vJmS3nofb33LW8gay//zaz+DXB3h8wXisOCTn3+OR5/YojPo8OyXhix3C37879xLfmmFl59aYWHuU7zhXe/l8w/8BcsHDjJcX6XZvELTvB5dNUxGm6RhSlF56vUbXFn3lG6BLO22V7IOUmPZWBkSKE9nz4AZnkCUCGsYSdATQTNrmKsEdaDRxtOJQy68cIUDR5bRQY0z7TV/mKVUdY0Vnr3HlvGTCuYTRGmZbFco68kWBhSmpqsiqqknTUMarwiymHpSIitD0M/RvQyUorQeVzdo3ZpB0QodaMqirdsyxhF1kx1B9miXmc1t374aOkugQoxocEkPKo+zFVkR0OSqZaaZ4SpBnM5hhadoJI311DPB9ZWa58+O2K5SlnTJZSWxxuBczGxzTBjFu8x0OwmjoaF7conh0+eJ9/RQoWNh0DKzsC/DekdRlCivyXqKNOpRTWdkHbBBzP6jh1k7f5Uf/Yc/wR1dx+E3vZnqxgrXr7xIlvYYrU4JBgf5nh/+cbLGsrCc8u//+f+EzxdYOrS/Zealio5smTmxvMEHfvjtyMsbPPqpB3ntPducfOsP8cQX/ozlAwe5dPkVOvoKx7/7fZgdZiaTGOlD6vUbbDQxpcs4f36FQaJIHPjxhI1Re6U+6Kf4JEaPZrvMhKubVLOGeaeYjCzaeLSDSzvMBHNdnPEkvQxhFFVdY2blLjPhvj7N9ozVyxso3zKj65ow0JTeEKUKm0SEcUy1PUZWhs5Cj8JZpBfMvMDVDaFqtTJohVTt7aketuWnUTfBVd++jPLbPin95r/85Y8EEgIVUzUN3oBHYhqY1TVBkmFEitA5TiaooE9hpowmI+pCUE88a9eHnLs4ZtAV3H5I8tiZkktDi1Ka0kCWBURZgtARsqkoXY2OA+zWmEGu6Awy6lnF/L4+UeBxStOb79FUY0KlUa79j0m/Q+0C9p24jTOnz9BNuzz2xU/xufNX+NEf+Fs88uifEbkpZ579PKGLqGSFiBKW9h1gECrWX3iIuaO3sHDkBL9z/9cJezEnbr0d3c3YmIyYrc3Iow3iIGDj6jmWThxn7/E7+Or9f85g0IUsYHNWkcU541lB08yYbj3Py89dZX6hx5995slWsGYb5pdiisIiZYx1FUwroiSntzhPnAc004K6qomyGFM3iMay9+ZlpuOKTidgazLDO0WSaQSKupxSrY8I85i8mzMtSgKhEMazOhphhSKKJTdWRizdurdN3AYR69c3SJM2TRwvDdjeHqLTDDeZMnHQW0pJF+fwsxlBoJiZurXiKIlzhjxNaBrL6nC6y8zNnbamKFAxaIkpLZV12B1mVJTQiAShc1ARMhhQFBXjYou6EAw3arbWxqzcMBw7FHNyL3zmrKSoDEppqtqRZCFJVyGDFNlUVKJpG1q3xmQLmm43pS4r5ve2zFQ6ot/LoR7TtuIK6IaQZdQu4L7v/X6+/NBDDHpdKJ7kdx9+kXe96W4eeeSTRG6KVgGbVy7zvg//L7x84TmW9h3gP/36LxLNbjB39Bb6h47zHz72GJ24y7FbTqK7GS+9tEkzrRmYdSJVs3b1HL2lkCOvuY+v3v/nHLzlZpw0vPa+7+b6pQuMZwWz0SrV+EVefu4qZ27UPPn48zt19Zb5pZjZxKKCBNPUhM4QJBnpvkXSrGWmKGviLMbXhiAOWT42z2RY0uuFbE1mlNOGvBsxnbSRi2p9xNzeReIsZlqU7SFSWm6MJ7gdZi7fGLP3lr3o2kKSsHFjk1RHSA3x0oDV1U3CPMdMX2UmXpyH6ZQgUNi6btt9HXhhydME7+Dv/cw//Zs9KREHfOHZKSeWIQ9LDh/KSToNearxUYeNDYu5eoN4rtcW1xVDyuk2W1sVnV4PFZQcPqy47dYlrl5Z54ULnvUK2ImrRyEEIfSXO9iiIN5/gJXtgnIyIuznBMqiUOy97QjbVy/TX+oTj6dMbtxoFbS0V5WqbBivrhJ1Aq69fJ4wgOFwi7ffe5yPf+brGGN46cnHuWnPAvsX9hMl+3jdm+5iexW2VlY5feqrnL10g/jKkNe9810oEoZrU15z5yq//+hFfJLwwqVV3vOT78HUm+y96U1M6wVm557g2taIIHUc3n87SjQEaZd8znLp6WeReDZNzPD8NnNxgvWGSEcEIiZIaa+NuxmBV2zcGFJvjqgxyLzD/NE57OYaw3GFjBUrZ64yv7RA1OtTbw8RZYNLFK62KKdYPnKAxllm60PCOCKMA2rX0M1ioixFBZregmW2OUV5Q1A75ub7+A4kpaSZlnQGOeV0huznzGlJNZxSbG4RxCH1aIKcOIgVngpnHFM3xXyLG+eZS2OCayEnluHgkqLbFaRJQ9ZtmVlbtdi6ZcaZElcFbG9sUhQNnV4P54YcPpxw7Khgba3gzEUwVbnLTBJrghCW9i9STWbE+w+wPiopRkPCfo4WDQrF4slDTFeu0V/qo9a3KG5sUzQBobBMbYO6NmHcDIk6AQ98/JOEAVy6cpH1YcrW+gUePfU0L+8wM9vYJh0c4uHPfZSDe06ytbLK179+hQ5bxFeGvPn7DqNIeM+7306w+jV+/9GL5GnEC5dW+Z4PvxWhhywd/U6urg+pTMvMwbqh08u4cfkFgrRPPme5cvbL5HHEpolZOX+duTjB0RDSMtNJJV4Z5pdj/ESzvT6kHm5SW5B5h73Hu1QbW0yqCrNtmK1t0987T5pn1NtD4o7HJQo5bF+9lo8coBF+lxndOJySHJjr02iBCjQHlj2zzSlhognqmrn5PvGchqmnmZb0BxlVNSNcHDCHoxpOKbfW0VHLjC0cIlBYU+GRfyUz3/oR36i7/qs+d3Yy/8F3ZMwNHDqMKKem3XnqBYRBjI41WS+lnk7BG+b6OUGoyMKUur7OeFRQVYrtccNo2KpPnzxX86VzOzMIr+hmmk6e4hVkTY3K49bx4wVaSybOspxmiBSooJ5WhE7jw5DGFG1zhXXoPEE6x3kjmZs/SF1t8ZM/+X7u/8yzzO+LGVRbEM/zIz/8Pr745QfoGEFpC5aP3s6NCy9x+otfpNPJ2HPyKJtlw7//6NPceSSjmKVsNWP+4YfehTKXSeePE8XQDxZ5+rlTfP+HPswf/K+/wF3vfA37Tr6L5Zvv5JFHvkS9vc25U08Rze/ht37zL2io6CQpoVaEzpPMx3R0iqumvHh1ypwW7NmfM14ZU6WCLIiZSEPiQ5wt0VGMlwJrLa5pD2TbOIyUZMpTNAbtWl1HrBWVpRXGidabF4a67RUTmkCAiTWpk1ilmK5uopIM35RUO+7lyjYY2jpp69tbUGfbfTFv3U6lt8QZy5n1V2/ffvimLnfdGjE3cBgnwLZRA50owiBGxiGdXkw9nSJcxWDQI4w0aZBQ19e5fn0TrXKur1bMKhgOG/7oKcPVnRu+UGniSDG/b5FqOiVranys0Q5M6wimdI6+0sSDCCrQ4wZDewsUKYWxrm1zziOkc1wLumTpgHK6weroGnff9Q5O5Ov4KIN4nu9882HOXrjKHcf5s9kPAAAgAElEQVSPcuaF0ywfvZ3nHvoU6+dX6HQy7vyB93L6mVP88Sef4cBiSjFLacyMD//Y25nvBbikj/JDaATnz13j+z/0Yf783/4KJ25f5rX3/S3U/H4eeeRLnPvy56itIprfw2//5p9RA/N5BkISOk+6lJGLiOl0yqVrBfORp7MscGtuh5mIibTouh38B2GMQlD5lhmvJHXZ4DXEQlA0ps2iAbFW1O6bz4Iw1DtFlQppanyekHqFVYLp6jYqyaAqKGWrFGq8beWCuLbp2PvW6NG6Y9uKpx1mTq/N/lp/ybd9Unqlrnj6rOWe2xMWFw17jwZEXtPt1YS9DlJKmqnF5wbRWBpdo1zB5uY20wqqohWwAeSRoI5hTyKphSaiaauWhScQllykyFxST2u8C0ikJ1WCLOy3iW9lKMoSqSCY12AV0QhsEuMERJlle1zSCZYYTq+yZ+8J/tWv/S52WvEzv/ATrF8suO34Hi6++CS37D9CE8SkRNz/0X/Hz/7K/8UDf/Ax+uOChVtez8baC7zr3i5f/co6U73Bj3/va3nx1OMcPjDH8sF5rq2/SLpnAXTD+mZDtjxHXUHYyVEyQquMibvO2lZFP2nj+0kYofBEcUguGja3axaODCic4fZb2wXUQAcUWjLQrScybSQ1E3KpsE3V+sttg/IxobAYrdtvUrPjllSv/jsHwqFk+7tvAJoG49sF3JF3iJlnTISWhiqQ2GKbULcmwloYpPOEOzrZwLYivlAJGr/jJJJtx1z9LZmTF0cGf7bintsT9u0PSboBeZSTRCPCXgclY+ppgc8N0kpqWYOZsTneYlqB9R2a2qE19KXHVXByAOe3WmbEN5iZbZOJHJlLQFGNDYn0xEGACxPiXkgoK4qyRCcZKm/IbEo12ULGOUEagizYHpcE4QLD6VX2HzzKL/343+fnfvp/554Pvo2ZaLjt+B6KEdyy/wgb21vccvMbuf+j/47v+9Df5v/8n3+F/rjg2LRmY22d+167xIMPX2aqN/j1X/gRnnjsyxza22f/zSdYH0+YX963y8zykX3UlWUyHjO32DKTLh3j6gsvtsy4gCSQONuqRXLRMBob5vd1seMxr7u1Q2kdeey5sDVjoEH6hrSRKLlTHtBUeGdQWJSPUc6gtMRQEZrg1QqlnY/yti2mFKI9oJoGayqMUJQegrUxY61pvEMGomVGAE61quEdZrxsa7yNECjV1nk5D0GgkEJQmW8/U/q2h1IlLFkWMR23G/t1Lcl7mmkd4za3CFVb6+KMJ0hj4lBimi5VWVJbQ56G+MijJoKKCenYcdM+AU87RCCJlaeXpiz0e0TdELtRtnUziwmdUOOFQhawVZfoylNulCSDhMsXh8wpQSnbjeaFuYRgsY8ajagmNbPZmPd8+Ht45exB1tcvUs2u8fZ3fy+PPviH3PPWH+XqjZe475a7OHf+aZ57ccIv/vc/T//kcdYvrPL0l/+SG2sTlg8d4CfedzfjXpcje+exxQzrNS987QtoGfDyxoRb77ib4bXHmb/rTpY7A4R0jKfbCBTO1qSZ5/d+7xPESpMFCtMYwkAQ9hY46gx+e0oaaNa2xhTXCwppWJjv4k2J1QoiS241VkhCoaitQemQoJZUqq16slLS0FY3t3VcHud3OuW8bAsYd/aNvlFbHeHaXSZb4Zxom10F+MZhpSdyCicFxjmEs2jV9tmbXSm8w9o2mSvkN3+7rm0Z7tqvmY4920PFdCKZ5RVh1MVtbpHoEIfHGU+axahAUFQaVwlqa+imMUbXKGmYjWtS6Tg5L3ngdMtMFDh6aYf+YocgjLEbJZWqCZdbZupZjZSKYV1B01BulKR7QtYuDunhEFmKNzMOLYQ0nZaZshwxWx+z982HOP3iZd74xtdydTzhh97/gzz64B/yuu94PzfWLnH33fdy9eWzPPfihOp3PrrLzP2/9TGm5ZDBXGeXmUtXLnL85jsZjjY4+9xZYgKSdIlbb389w2uPI5NDLC8EyDTbZWZSTHeZyYKAJFC4qiIcxIS9BfY0JX57ivCCje2S6WrF5RjmOinelJigtTiIHeuGRrf12lIR1JJSemIBtQgxuP+CGSkVjfe7NUnetwcUzpPicJEicBWRauu+2emNs96g/3NmvEftMGOdQwqBtLbdCpCtI/1vfCiFPsBs19APkK5GpyFKW3SgifIucZpAvY1z4G2JjjrU9ZQ0DJnPw9bXU8ywcoqUCbUekcUhbzu5wFfObeOVoGwck2mFLQq2t0v6ytOsjZgmEFWSqnFEoSKNc+ZOzmEmgqTf3gRWVUmIwqzXFMUG80d6bF1wBHKBx558gme++iUOzOcc/cBbiIgQ8T4uvvAinb0dGgyf+v2PcuJAl/6xJY7feTcP/offI05jXnPbYQ724crwHJeerbgQCaaV5tBSivDbBGFGlGp6hw6wde0cR97wo8hyBdd4hIzQWlPMHBuFaBtB4xAbBgw6Kcv75lk7v4ZVks6hRdbPrDAxBdlczNGlLmevzVgIAwIApzFeAhUz7wiERhqB6idEsxnltJW1x6HGCIuXCvMNaT7QeItWigiJVx7nVFv9JQUBhpkKUN7Q2FY3HAWa0jd451o1jJQEoi2kDKWkca5dzm0aAi8x7ltadIEw8LvM2MKTLDl8DFpDlHdJ8gBfTnAOhP9/SbuzGEvT+77v32d7l7MvtVfv2/Tsw324SaQo0RYlypYdBFJiGEHiOA4MxDESCIEuFOXCsBIGduAYQWIicSzYMGxHQbRGG0mJ5IxGM8MZTs/S03tXV1fXeqrO+u7P8+TiNM+YBjwGlLqvm8IHbz3b//crkGFMRA7e0G8ETJIUYz1OWmKlsLpgrfeBGSvmZgZHBS2VMxxmNPTjmasYVCWosikYQTNu0bvSo8wLotPLpElBWeUEVpM/mjINpvTPtdm5UWIaS8ys53d/97uEyTGf/8xfXpiRtiQOGoTECzO988/wsacv8I2v/1N0HHL+wtNoXXGczM30l9rsHL3Ps5fXsfmMgU3JRABPnuPk0V1e+NRPImcppYjRj82cO3OKb27tILXAaoGNApY2W/SX2hzeO6RZixDrbU5eH+FqjqgXcuVUyDv3H5vxDuU0hQflKgpRApKw0qhOTG2ckGQOE/K488/i5LxR6Aflrhb3Q2a8n5dHej0vWiiFeny+N/8dyzz9032IGa3nyRM4qJyg+v9TsSQIibtqvu/0JaGw6MAS6pJAWChTavWIWuCpxY6GbNIIJSYSSBnMCwSUoV0zxHGKNPMers9dFvy1L7QwdU1PK5Y3anTPrNCqQdDT7BYeGUbslZasoQmUZXwyJGi1YJQQSU2tJtnY7LN0aRnfMHTWO/jDitk4o9tvkKYpqa04SDS/+n/8S06mx/zoZ7/CV3/u38cnI37nX36der3Nz/0XfxOdKq5/8/cRTNEWhlt3efXNe5Qzz/pGn7VTqwR+xq3b90lmhpOjMUla8f1v/gm77+7w3V/7OisXrvBoYIlQJFWFikPyw2NsCdk0QxtLv1Uj9m6+Gioq3O4ecWf+32qpp3i4m7AuPIGyeMrHH4oCY0FUj+tq8pLJMMEHAXHbYGoBXkuQAh0obBDjpcdJTyQ1sZTYxxlIUjKH6CTjH6Qu2nmMbAWU3qHcvGdeawliPnDrpKASHm0MpS3xjzviHPZxAN8HPy9+5MzCjJQZobA0Q/OBGT/7wEwNGrJJTQcLM4aMSBniQNBqKqRRWCcXZoLI0NOK9bPLCzPRUrgw8/7BdG5GVAsz2TAlkpquMaxeXGXp0jJlJ16YkV7S7TfoqYAqSzlINKtrvYWZdqeLT0Y8vPv+wkwjGy/MhHbEcOsuB4PjhRnnxgR+xrV3b7C7N+DkaMz4OF+YmRxVrFy4wrkLTyzMpLNkYYbSoo1ldaW3MJMn6dzMikYZw1JP8c6NyQdm5PyfS0OUKDk3U/NmYaZsRcRtMy9wfWzGK7MwIx6bCRULM1rMzXgrsV4gnUV4uzCj4LEZPjCD/cCMVpS2xAqxMKP8v/U4Cfh3PAn43X/8d3/508sOrTxxAPWOoBYa4naTUAXUYkdV5QSmjZQ1lABvJ8S1GoiSUCpENSEbTygKS1rGeCFZ6sVoadna92w+f4lGr0YYGNLjAbOJpV/3yLRChZK2t8xswNqVdQb7B9S6ioPBmKIqODyc0FxZRpYweXCMNIbCzFcEw8mQyWjC5tlNptu72M46H3vhHN1uG63q/PFv/yvqjZCtd99lmp4wGoyweYYKDNNpSdSNyMYFzhaYfEazFTItHN56ur2YztIGLq4zHR7xkR//c1x/9zqN1Q1G4xNa7YhrL/0hr35vhyCs2Oi2URU0A89xMmXvqIDCUQhPPq2QKdisQsWeIDbzGFKl8WGNvCyxUZ12GCLTkgmaMi1hlmOVICFARvPhyVotJEtytKwTdwMmaYYOQwIRkCQlPq+Qwbxax1pJf6nD+Hgyz2gqLFUxf5zoxLw/b951rzGqTj7LCNQ8N8daOw/km3djcTj7YG7gtEv5+Bpo5el2DCa2BEZRe2xGuQkeCEwbrWvzfjY/I4wiECVaaZSdMjuekBUFuY0RSrDSj9DSspfUWX3yDO1uF2M86fGAIvN0I4dMKzrS0TQCUW/TP7fMYP+AsuaZDhNSJ7l/Z5f+xirFsCTZOUEaw3FRoKXmaP8RB4NdVjY2efjeKwxch4+9cA7rBSvLp3nl179OiWfr3XfRRcqjgwE2z1ju9DkaZ3TrbcajKc4WaOvodCNsAbPSs9SPqIsK31liOjxi6fJF3nvnXb7+q/+YzdOnabUjfu+f/nPevTciCCvOr3XwKdRFwWA2mZsZFxRaUE08Nq1waUmjKdCPzXihIIwprEM0m7SUoUxzpo/NmMpSOk+iI2RoUBbarYh0lqFlnbAdMskyonqM9oYkKcnLEm0UUglKC72lNvu7KV5KbGFR1iPNPBF2fgSp5llOpkk+y1DB4wZj6x5fnMw/SH/zzzqQ+4k12MoV9UHC+VMNwkpQjUtcnBDWNNgG9biOVFClCmEaBFETVSqq8R0slnGWY+pdquOCTlthqZFXKY1Y83Qr4ygvmW2fIMuStaefxgpLeXKCTTPW2k0ym+L3p9S6bcq4wbtv3GIpVqAFm+sraJeTtkAexgSrddxuxngyJIwjzp45hQ8c8eoKa8bx+vevsbZ5gVo7ZjIZsNnv0NnoE++X3Lk+4cK5FaaziqBf5+yTH2f7ey/RX6oxG4wpphl1KeifrvHxz/wIe3duYbMZRZoRGXj2x77Km3/625y++mke3XqL3/ztawgv6cQRSlqSvCIdeohBJDnWQCMX6EiTNSXaSYz3pM4TK4HzFSo9RpoAVyYkFSgD7cCRx/LxjUZB5CS+yHDekScTmkGMzVKKicRIReA9oyyhUTPUm02GmSUfzmjokBRFngv6NUEpJOQWbQSFkzRaNaazFIQjqSaox7lJFtChIlZq3lT8b5xZnt00bOWW+iCh04BWIya0BS6fm/FBm8DUkAqE7VPJCmXqKGeoxnfw0jHJclSziR1bOm1Fw0cUNqERa/LjA6qNJfbu3aDhPWtPP03pU+xohk0zWuvLTCYnGNPGRCFl3OD292/TCiWFqXj2+UsIl+NEhhRzM2GWMpwMqbc7fPrTX2Lr8D5OhQszzz31NLVWTHPlMsWjW3Q2+ty7scPR4dzM8WRG0K/T6SpmU+gv1TjZH2BPCsqy4uzFM7zw4kd473uvYuzczOraJk8/91me/9xfIE2PeHTrLX7nlQf0OzGdOMJUgjKvsPnj5IYkx4bQyB26ZXAynBtxjvyxGeMqbHqMMTHFZERiBSLwtMXcDNITuJLAeUThcd4xS3KagcJmKdMTi1EKUXjGeUqjZmi22xwnJflwChJSFNJZ2oGmFBJVgTACJxW1OGI6SxGhICnnZiYji5MVYSQJpMZj5wWYH/Lzodu3R7uKU70YGUYUQY3MC8Kex2UZXkmsS5iNJ5R5QVU68un7FJNDsuwhIqiRlDmN7uo8cjRw1NqKZttQqysadc96D+p5Qe2p0xRJwXg6QmYJRZIQLm/w8MGQcgSrz15kuHVATMrTz65QhJLKa27cuocvBXFW4WTJYGvA9OSQRhBBDl/5iz+Dz0uqrOS77zziwpPP8dK3/pCtG+/RaXd56vNfJqgF1PprnFqpEbUbKAoiBD2VcPGJTWajhLjdnP/Rg/mwYTI8IGxEpPmMz33lp8hPZrzy2svcunvIw+tv8drvfIdZaslnCTUFTlZ0ux6jC4z3rLZieo0A05R47YiqebedNZJGzZB5Q2IVvXNnaK6usHrpFLIZU4aGIqixtLpEZ6lL6RTDSUHO/CkAtjVvEDYOURSY1FKlJXUvoSrJRxlBkRC3DL4Z4GYZq2d7VHGEbNSwvTpjZWitrWCTilYY4hOPNiE+gmY3xjRqoAOSLCdJHLV+94fMzB5kCzNlGJF5AUG0MJNNjxZmptMj8un75OO7CzNWQKO7isAQBoJaWxHWpwszT20I6nlBf311YSbU4cLMre/foxxB0IkWZi5c7lCEkmDqeffNG/hSUEcuzIwmIxpBxOzohM9/7kV8XnLn+snCzEp3ma0b7/H+Gy8tzFx+5vLCTD0OiRDs3XvwgZlGHScVVSlYigzJ8IBTly8szNy5+x6vvPYyr333XyzMSG0WZmY+pdv1VNloYWap9dgMFaLKkd7hQr0wM1aG3rkz1Fa7CzO+3liYabYblE6Rln5hxjuzMBPhMamFolqYSU4SgiKh0a8T1Bq4WcbS+fWFmVFdM1aGuNZcmBGFXJip9WqYRo1S6IUZHdc/9KP0odu33/mffvmX48rT1p5auyLsKEohicM2lZcUhcLpnCKxTLMJQWrxPsJLh27WqdWXYHxEWKsTxBKBReqKqnKkU8twqNifGgyetF3nZHBMu9MkG6dUs5Jeo0G8GuKOp4xGY2ZeUg819mDesrJytsf05gGTcUJjNWJ4coyykOBQTc1KZ4lsMqKxtEI+HfG1r/19Ljx1hiYW7SdcvPIxyAtsLOkYQxEu0VmuMQsjjh/eIc9K+v0+JydD0tEIJwNWN2r8lb/+i+BrnL36AkeDhwxmKR974cscHL7Pm6+9zTdeukmWVrQbhlZdod38+z+PB1GP/1M4KhSRl2RG0dhYIq7XSWxA4gSHkwqTWtpdw6N7AzZPLbF/Z0I5nmHLgONpiUQThppIBJi4SZYXNJt1ElsRGU8YVnjzg9YXiRUVSkqsBZvkTPCIEkIjCZotarEhORrixzNU0zBNErTROJsjvaDWCNjZn9C289VSb6PL1t09puUHtykv9j1BJWlrT6uv0Q2IW02EiKi8pEThVUWRWPJZhs5LysIiTYhu1jFSIWZjwlaDMLQIPMbMG5jTqeVw3zEuI6Jel6RuOBkcE5uQcpZRzUpOn11GdwyTO4ckRcLMS2qRxh1mbF4+RbcdMbl7xFhYmj3D8OSYwATMbMGzzz/PaDainM0Ye0ss4Wtf+/tEwXzrDQdceuJFyAu2Ht7h1PIyRbjELN1FLK2hyhF5Cf1+n7IqmRwNCGodXvzZF/nSl/9DKtXm3KWnORo85FOf/TLdxhkq6fmj3/8G33jpJqWtaNd+2IwUCsxjM25uJvYSUQ+JVnvYfH6OmDjBg70pcQVRzXO0O2Vjo8/Nd4+QsxRbBhyclBhl0EoQiRATNynScmFGGEsttFRyfjHhpQQ1vz2jqhgnGZkAN8uJI0PQbNGo10iPTrCzKboVMk0SFOBdgfSCzpJm+9GEdhBglKC30eVg+4S//Yv/9jjcD92+GWPpr7dxswE4S3pXo4KM1J+wfP5JCA3NxqeRzQBla0yyjHpnhbB4i8l0G5ntEcQ1tLGEPiS3kmRWIpVHmnn290CWdLIZrZU+rabg+rVHfOTjFyhsSaQV0+mY8Z0jVl98iun+gGJsabQb5CdD8vsZcj2ExFNMCuq9JeIkp/Axz1+4xBf+/E8g/hDqccTqyibOVdy8MeDn/vZP4f0hk9mEoZC89u3v8NFnnuHJiy9weDBADQ+In/o4mx3P++9d59xan3e++TrLqw1+8j/6z2l3esxURTU6onQpH/n4j/Kdb/0jmt0OXe2oQoVxnjCaPwAldxRYcJIoCil9RtDqAZa9R2NqnS7SSybHE4QI2N0aUZSWiVLcemUfL0ru7M0QQpBjaY2OeGpjhdHJEF0LOJ5VlOOSmcupShhXjnogWFrpoivN9OAEGQrC0FAVJV5p9lLYLBV5LUPJiOpkn8o6ltf65FlJnqZ0lrsUw5yirNBeMJtknGlHWO3QXjE6GbGyucLurd2FmXpT01+v4WYDlIP0bsDe9gPAsXz+SYLWCqZ2GdkM0PppJqPrtFavoiffYjLdJioUxDWULjE+oAw9ZcHCTLMb8+6wJM+GtHp1Wk3B/p0R55/cpLAltkrnKZkiYPWZs0z3B6hpSqPdYLq7zzivUF1JNckpJlDvLTE+zjFhzKXnn2B97TRhGHLhsuXC+Ss4V9HsLfH8pz7Lw533F2Ze/LG/zJ3v/SFPXnyBxs2YEsdzX/4pkuke7793HTEdgow4e7HJJz/yZdqdHsJcJxnsU7qUcVLy8rf+CZFZXphpxyFhUKG1pCgq5jXtmvCxme7mKWaTCbvbU5bjGOklw9mEDi12t0ZoYJJV3HxjhBeOWw/HOAFHlaM1OuLCcot8miIjyXHiKMclSZkuzHRbEaoVEE492XiKDAVBLKmyCiEV00qwPlOoboGShupkHw8sr/VJpil5WtBZ7jI7nOBwaC+YHE05045wpkQ5zehkRNCufehK6UO3bw0tKCZjtNbEuoUOK5qtiLgZ4fUMJStc8g7leEA+fpuIW4TFIcV0Suw0YdCc3yIJiYoEOjDEzRAlNXkGTirqDoLWPCBq794eT11d4mjnmHyn5PD+kOT2BGsN+9dus3v/gEGakciMiSiRqzXyWY6QJWkxIUtSvvQf/A1a/SXQhofb24yHAw4ODnj72iucvnCG/+y//i/54+/vkNs+nTrYJOGn/73/hNbF5zh/6TIrqxuktRZf/NyPUQQhZv08aXLM2kqHcxfPIXWb777+HXprK+wNT/j8j/91DvZ36DQ2+K3feplvf+8uH7tyBQv017oE7T6JCMmI0M0GuXcIpRgfDimnFWdO1wlKz9GtAaP7M5LdCc9vtnj2Qgc7Tgikw/F4XktYNJKNfoNBkhPVFc4YOr2QpSU43ZHI0LC2FNGsGabJhMZyRP/ZDZprPTB1fCVQBZxuKUSjJDQB3lu8mB+UlpMpLk0xAmbDMWWRoq3C5xWBF5hAE1hJ+fg1sJhMfshMKOXCjMagw4pGq74wY4vRwkwx+C0ibsHszYUZFZZ4SqwrUbUQHRiE8QszMoS6gyj+wMyptdrCzPBeQnJ7wmh3uDCzV1kSmXGUpjjlyGc5ccDCzH/6S79Iq79EXSuOTw4YDwe0ev2FmcoE/PH3d+ivbC7M1DqdhZn9gz3SWotnPvOZhRkjYG2lQ+vsJRrdc3z39e/w3rWXFmaufevX6DQ2uHP99gdmvF+YKXVERoRqthZmjh7uz81s1EmSiqNbA9K9cmHm8mYTO07QEpAC5QVG+IWZUeGJ6opCRQszKy21MKMdTJMJ3VPNhZki0fhK4Kxko6kRjRL8B2as9ZSTKRq/MGPxCzPIEBNoKMXCTM0VH/pR+tAxk7/1lPLnTsd02gFxU1ELBVFHopt1gjhEVDHCOLR5hqUnv8q5H/1pkCHvfP2nmKUPCGQH5Az/+LqySAsmw5TMObbuZxyPDb/x7RmNlRbGaPIyI/eWWjBfYqZJTqwVw2lJKw4fP+TzWC0wBRSipPISZ0uCwCDaPZQNWb14lk//2E9y+/o1rr36Lb705Z8ilfDEuRfoXjrDH/76v+Dg5i0+/6krtFeWuXDuLFsPD5nt3aVz5fNsvf8atbri5ptvsCxLZLsDwQq33vkWL37p59m78ypBGDMpJFcuP8nrb3+Pra0tHt5O2HzyKR4+2OH+zQecWW5TKyweyfF0xrnLazxMRkRVSTPSKA9jPGvLHaSr8Wj3iO3dCan3BBKyaj7OoSRoaQmQXN5sc3SQ0upG7AwzxlmJdwKPReMwOqTfDanpgHbDYKuEYibQkaHC4pWn0+iwc2ebAImqaWTwuEYdcH4+EuAfP6KzShFZj2l3sdZSTktmsxkimJcKls7x9qPpwswvfCRkbVnTaQeEjZJGFBN3BarRIIhDpK2BtmjzDE//pb9DvLLEWy//Lur6P2KWPkCLCKkslcixTuNtyeHeCQQBW/czHh3V+f1XTohqMXE3Ji8zrFIE0qOVYDpKacSGpBBESiCcxUd+Pj2QOayw8zRE79FaINo9ZLjM2nqX2voqT19+nt/4Z/+QH/3qz1GWE5449wJv3HsPn4y48frL/MxPfJb2yjIHh2PW19eY7d1lqlexxYhxPma8dY9lWZIpQ613nlvv/gmXrzxHmQ+IO2sMRxOuXH6S8fGIP3j5Gzy6m7H+xFUePtjh+OYWneUOtcIiteBwmHD6yQ12xydEVUnNSAIpoRETNkJMGXPn3iOOTnJS7zHCk1v/uDHEEihHTWvOrzY5OkgxTTiewiQpcMxbR5TzBEFAvxuiyoqV5TZUKekMdGTIihkqDml1egzvHWCLHNlQKC1wbl6jZN18lAmYP7yUGu3c3MysoKwcRZJSGTc3Y+Hao9GfbcwkFRHWKWQIXnl0PUAqg1JgvMB0amgNVHc4fPvvMbz9v1Alj+Z13EbhGFIUOT4PkCqnzBWVs0wnFcpB6CUnvkJNRoSNECk9HcAWMyqviYWkcgXtuiQUJU55rAeRCTIqSudRWhJqQyUUxWjG6oVNdvZGrGyc4tof/z+sX7jMg+1dzlzZxIclJ3fvc2r9HCEBb9zaorx2m/Hs9/jv/ttf4R/8xq+zcZxg8kPWP/njLPffodO7iBNwcOM6T188y923vlDPbWIAACAASURBVEVc73Dr/j5nn/4o7157k5e/eRPdMgS9JX7iZ/4S/8Mv/ALnmh3SgxH3lUb4grb15LOM5tiSdkMI5kOwurSc7CY4JoxmJbaAhgFd5jx3dZWd94+pNQwqng/VVs4S92rcP0xIq4KaFUxkhfGGigqfpxyMJZ4cu+Px0iOdJZKaXMy75RtiyhNX15nuD7DVfBZJWYGNFHI6v3ZWkcNKjfaOwklEURIt1xEVaCJUv0dyuE9yUv6QmXFesOxCZAg6rKHrmqyqaD02I5sxYTA3c+vX/wpOSmz2EOvV/OpZVGT5DKU0VTHG2RCnHMmkRDkwkeDEV5yNcmRhkdITFQVOWiqvaWioXEEz1CjvccozzS2x0zgsuavQKpiv6ISkGM3IGmD3JJ9+6gXuX3uZ9QuXCe0MHUp8WPLE+fNMj4fUX6zxxq07lNduU0rHf/MTf4F/8Bu/zlJ/m3rNEeqA5X5Ap3eR0ckRyd4Nzl65RPboNrK3wr2bd1m7+hzvXnuT71zbwRWOsL+6MLPWaTA9GHNfaQLpqZUlUSBpjuZmlJ5S5gF2MGEwcNTUmGHiFmZ6uWfl6R7DexN0x8wLUbVcmLn7aIgT0PGCwWMz3niKH5jJC7aPB0hf4QVEUlOEHvuoYMWPOf/UJsP9I3wiqfTcTKVBZfOZtrJmsVITCUHhBKIoUe2QYFaRlwndtQ2Sw33SUfZnXyn91Sdif+WUptfyhJGku1Snf7aJrwRBqFAyIIwMeZLPH8rVGxRpAVphqwwhHUXuqSpJEAQMRwNKZ5hMcyZDGE5C/t5v7XG6F9PvBovrZaHng6A/GI2QziHU/PtprcUKRVFkGCQlEEhHpWNEc5nRZMLHv/BFknzCeqeBcJ5Gp8up9SWSPODR7i06rQ2KIiVsRNTDFlv33+P2ze9xZu0SKp9x5onLSFewut7jD37zm4h0j40zT5KMp6TZhJlTTG3K4cMJqxtnGUxSvvrzP8+rr77CmUtX+Nov/QqtMECgqdVDiklOP5BUWUFVCzm12aIQBdJ6Yu/IrMXnIBo9hE+YTQvCVky2n7F6qcO9m8csNSSpUewfT5nmlrrQRFJR8yVXPn6Zt9++Q55YEjwawWZgqK/XuH88Ix+XOK1oVI7Lz2wgm4Za5Rge51SOeb36coeTe3uYcB4Er2sRx9u7GDV/6dvq9EmTGUGnQ2pzRidTuvU62WjGW0cfbOH+xjMRmytzM42WodGKaGwYAhEThIo4aiDkvDFXqBlRrY0tLFaArTKKcoYgwjqJ8ylpUpEUhiybm9kZNfjffmebKyshtWY0Tx911Xyb5x22Amkkwnqknpce5kWJ0AZb5GipyJ0jVIJSBYjmMqZe59zVJ0lP7nP67EWqvGRl8wy9VkiSB2zv36PfWKHZbTGdjaiHLR5u3+DG9Vc5s3aJdt3RWz7Fxz7+Ao+2b/MHv/lN4mJAb/MSR6NDrC3JC03qHXsPjuZmpOerX/lZtre3MPUmX/ulX6EZG6Qz1Ooh+WT+SrvMM2wcz81UJVI6dFUwlIZGWjGJOrRVxmxaYGJNcWxZu9Bmb3dKTVjGoeT4aMY0t7S8xmjFRsewcnGTt9++g53BWFRoBOdbEaYbcndvRpnNzbRsycWnT2M6EXYwpigkaZoT1SNqyx2OHw4I5HzuTdXnZmKpKKlodfpMsoRaq804HZPMSrr1OlVe8fr24Z9tpZQ7ReEsZaVpmBACRzYukKHAVyGRyRmOCqR0COvJhjM8OYYA5xxVUVGVEAQR3qj569HS4oXCS0/qKvIMitSjlgRUDozCmPmKylUloQxASkpXPq5qBqqSKIpweTkfOlUBtVrEkx99jqPZlMuXTnPnre+hUKyeeRrKGYeP9hgOjokaGpdpkFA3ht3ta6wsLRO3v4LNU8rRfcJGn5e++zLj77xCFNTprF0luvAEIhfsvfp9jvMJ6+eucumpdToba7zzp29Rb7a48vSTvPna25ztN6kpSewdalJiY2i1YhrL6zwcHZAAMQ0Yp+yICceJpco8X7nc5PZBTq2haIgI2XHsbY84u9xi6/4jBirAVxWBlKTKIsqSS1c20MrzzHOrTB9kmOUaL7+1w0lREQ1nPLve4lp1QksLdqaeo60TRsOEVkex/PQ6LRcymeaM3tkiajUgs4x9SRRqTL8FwHBS4HxB1Knjsnm+d6fTYTqeEIU/TKiwH5ixzkHgqFKPCAt8FSKzIVmpkdKhkOTDGVmW0GjHj7eQEXlR4b2FqIlXU7RUCzNVDnkGSeVoqrkZoQzh41WkoCSQmkoKvCvwUhEEAWVVIKIAKocSELSaGC948qPPsb27x+VLp9m5OSRW0DhzEZeNOXx0wnBwTHtlE5dpjFILM7XQ8Own5mby8RZho8+v/u//hP3hiCios/bJLxCFdX5k82f5h//zf0+r1eXqJz7G+ashnY01rv3JS9SbLVZ6PV5+7S3O9ps0jCS0czNhv4nWgubpDbb390mASArEWLNTZpS542GZ8eU/t8z924+oNRRmFqI7FdPDhI1+k9vXH7AnFNq5x2YcrixZObO2MDM5rAgaAS+/tcPRNGVFVHzsqWXeeH+PlhbsJ4KjrRMevpfy5Kke4UZI180PzEfvbD1OoNSkoUPZCtNvkSYFU2twvqDRmpuxmf3AjPvw2bcPfRLwf/6Pf+eX2yF0mgbnK0IjQUHYqpPOxjhncMpSOIu1CSIIsMJQWYtwMdZVVLbCVg4hDVklKcsMiyJNYDCEN7YLahG0Yo0IJFJ4vBV47+ZzN0Lxg0F0I8CJ+RSycfMYUFEJfKQwaolRNiEiYv3qE9jZAS/++F9k5+47xGGNdjMgrxLavSVyPyZUkqhe53h/m2c/9iPUa12M9ChydLxE1Ajpr57jIy9+jqktmOzvUEYNfuTP/zSrqxuMpic895HPcTwes7V1mywr2b13k5VOh7vv3OTiehMRe1QkqHUb0G7jlEDksNwN2Ts55vRzK/jdksGsoFCC3QfHrDRarF9eIQpANObLb58V1PtNnnpimUZScenqCmu9DtvHE3YOxyyHBh85amt1jm8O8WXJRAiOkophUqKAViCRdl6Xs4elUXg6p9Z4++W7PBiMGJaebDhi9fIGUS1ExRFukuCcZePUEnaS4Wc5IghgmpHbjFo7ItQhDwYfrJSuthyhVnSaBqH9PBs7EISNuRkpG1Ry3uwq/HymCh0tzEglyYsMnMJLR+VCiirFekmawP39nPf2K2pG0owem5HgLXjv0MrMz8WEwLv54atwDqsgEIKZLQmtxoUeJfqMsgmbTz1Db3UNXYx44dNfZvveOzhfsNxrkVcJ/f4ySXVIQIgMJMf723RXNtncvIKRnqP9B3SWzuHDOsvrczMmjNi5fR0X9fj5v/rXaDTbRLUmZ85f5Xg85s6dO5Sl5cbb32dzZZm779zkwnoPEVWoSCCWAmS9wzhNCa1muRsyrCzrV7sMb00Y2oxSCXZv7LLa7LB+eQUTg24Zqgpc6qn1Yp5/dpP6tODS1RX6psbOdMbhwzHtUOEjR1yPObk7NzOQkuNZxXSSgZ+bqRxo5xk6S9cE1Hpdvve9W+zujxmWHl1aeudW8EYQxDXcJCFs1VhZaWMnGWWWI02AzqsPzBDyH/+t/+rP9iRg6CqGmaF+nLKyZpjMclRDUaYJTsZkUhFLiKIa3jexZYoSilIIBCWlnbdnCh8wTR1ZmuNKjXOCqjDsH06QNiV3dZyHQBq8K3DCzccbAjefMpYwu58Qrke40KDcfF5p8+JFDo73SSdjTj97mcF0yoWrV7l3830un75K00Q0asuYIGf38IgymzEZwLTIWF+/SDadsbJ2jnR2QlY4ut0uw3EdoQVZmmCCOkoIfJpz/olP8ehwj1df+hbNRo0v/fjPMDoesXfnbb70xS/yz//Vr/HU1Su8/dobjPKSNx+MKYuC2EhOKUl7JcC0Awor2DvMuXR2leRgytLGEkcnUx5V8wiRdx/sc+/BETNd8vypOk1n6Fxsk3hJFCo2P7nOg9tDdgcThPP0QoOuQRhFuFSzP04Z2Xm+zVmlqcWKaLlFkac0Q8nW/pimgCOl2PvTWzS0og2snoo4euTY3j3h0f6QuhAsLTWo9xokO8fc2x9ReY0SCauBZvNjlzh6cECajX/IzIENiDNJ/TjldD1kMsuJl6KFmbEtqWtNFNWo3Awqj1IZpYsQlKRphRMOqWKcU2RpSplJHHMzN7cHSJuCrC3MUOVYAQqNp8ILibSC9MHcTCDVvBpMSS5cvszo+JhWu0N97QKD6ZQXn36WP7n2PTZXTvPdl77Bem8dTcru4QFlNuPh1ttYDJSCer3Fyto5ityTFSO63S7tTh+hBWWaENTmZrbvPOT8E5/CGcGfvPJHFLMxmIjlbsnenbf56PPP8o1vv0wnCHh7e27mtTv7eOeIjeSyDwnCnFrdMJ25uZnLbU4OpmxsdkkfHjOocqz+18xQ8vy5OnUX07nUJLOgA7cw8/B4jHCepX5tYaYcqoWZWAjWlKbeDAjbNYo8pUhTpnlJXUm2jqfcOhoTC48RitVTETsPp/jdEx7uDmmquZlmjYWZggBDwoV+g/VLZzh6cIA3H15n8qEfpUcjz2ajJHeaJIF2L6IsDUnhUZFGOEdWSLQrEMLjbIAzGiHB5hVSearMU9n5Sb+w8273ZGw5Gs24e5Rh0eSlxePmjSlGQVLipKcsPVqClIbW2RaToE4rFhQnMwgK7m7vsXLuAp0NRVE66rHkxq23WFpu0e28QF5KBsd7PPfJz3K4/yqtTsx4OCEyEUZ7lvsdhInYPRwj85QDEdCodynylOO9bYKoQZrOWNq4jJCaQJScu/I0g93bvPT//l8sr53iU1/4AuPBiI+/8BxVljLYfUgjh5QMLzWnvGH5QhPTrjF+eETUrtPva2ZHE0JpubU95MR7AqWRuWMDz46Zl/vd3U7JmBI8nNFZClgRhvalPk3puD/N8EIzAV6/PqCsLEudCB8JTntDgaBRl+i6RsWGk6MRvhZx4fISxcmMncE8HmU5FtTqEXbmUM0Anaecb8XsjDPuH42Rw5xQWwoxnxpXlWUahPzpazdwzvNvLsSPZ4peVMzNZJJe0zCdCMLG3IzGkBUW7QqcE8zzCgxKGWxezd+/FNUiEkNYyIqKItMcjWa8vp2g0POV1A/MCKCyOOlxeJSf10//wEyxs0/UbxKEgv3dA3qnLhO3ooWZyWSMKE+4/t4en/3CV9i++X2ufOSzHF+bm4mCkKPjAYERbK61ESZiZ/sh5ckRByKgs3yBIk8Zn+yhpiFpOmPl1BmE1EwHA4JQIoRlOD5mf+s6n/rCF5CFYjSesnNvi+3r79HIwSnHVEtOeUO93yJoawbv7xOttuj3NcOdAaER3NlPGFMRKE1YQd87dowH67i7nTIjp/FgRHMlYCMOqZ/q0pSOfJbgRcj2MGF3klNWlosr3YWZSgsaoSTu1iCcmylCuHBmifH+lP1JQaAV63VBEM/NxK0YnaecrgccpiX3j8boSY4RczOlrDCV5e40ofyBGfVvPU76d3+UjNCMM8u0EjScZzQtCApBN4rmHe1hjJIlNk3R4fy8w9oEkEjj8FUdzzyhMM0qbCXwUoNSDCczbg7m+zItwQiFURJpK1IjUP7xrE43IHaG17834KNfPMvet95FXwzIxp5oDQZbN6hFAakzXPnkM9TiVaIo4O69G7zx2u/R27jM/evX6HYN0jTIbDSffXKSwcmM4+kOoQmwyZDCK1qdJbZuXCfQHuUr1tY20EbghKOoSrr9Hid7mvOXrjItc17/9is0Gi2a7YCD8YC1tRaTkxMeWcNaI2bj+XVULrj1/W3OP9OnsdEnOz6h99QZXv+/v88UqAuIpMRLSaMRc6ZI2Kk8fQS612B4NGN34NlWUzrfnTJSljWtWTu/xNt3DyilprcScKnX5TDP2N1LGBcp41xRHmbEJuPCuRr2MOPO3pRaLDm30uDN/QlpommPc9Y2IxozizQBtUDSTDK09Zw93aS1EvLWK7sUXrAShGA0gyRHa8eTmxu8dH1rYWaaOsYZTKv5PNRoWlAXGh0ZZOEwdQEebJripQdhwQoqcqRxuBI8IUVeUFQlWIOQBpRhOJlhK4/S8w+WERFGSbw0FKJEeYlWoFoGceR4596Uj37xLMePhhQy59Gh4+y5TQZbN0hCQ+YDrnzyGa7feINud5krF1Z459u/xfKFq9x/49t0l5tI02A6STFhkziIF2bSo32a7SaFVywtn+fWO28hXInyirW1DbK8wgWOyias9s5xNBtz6eIlTob7vP7tV4jbbZrtgPt37y7M3JOO01GNjefXmW0d8PBewdUvXMEEkB2fUDvT591v3AOlqFtBIxA4HI1WnTNFwp4M6FuHDgUmsewOcvZNSu3+mJGyPFGrEW90uXb/iBJJbyWg2w2hLtjdS5hNMoYzSXVcEEnJhXM10sOMO/eO6UaC052I904SRlPJ8nBuJhpXmMhQixxZWaKt58KFNvWW4a1XdgmlYinQDJUjKz1aO670lz70o/Shjyf7nZibIxjMYDSGItMUCtJRySSxDE7GJLkjqxyTxFI6g9MBQdzD2jpoT1nMo1qLrJj/ztER00lOkXsGSYqnIrKCKJbzN0hKEIWaVj2k0Qx5/80TXn1vyOm+Zu+92yTrTfpPXGKpUaOTWY6mjr3DEe26w4gILyWHt95j/+Y1YhlxZv0s4/GQ7tqTrK6s87FPfoIwDEnzKUmSsLp0munxgN2te1RFyb0b76B9ST2IqHeWOX3hEnjFbDIh0E32dgfsHuySeosxhqtPX+X48CHp3iFxNaPZCXnmpy9zbrXLSZLw3Vfv8923b/PUZ85SDlOOXr9Bs9Ni51s3GSpFpRTLXkMO3U7EwXjGuJA0pOFISLZPUizzM7ZzOmKgLEJr+q06xqecO92jI0uSrOQ7twakwzGXmoof+8R5ykpzJlbUvOXtuyOuTywXn1ih1jPcTlJOnW7ziac6jDTc2pswzhyR0TycZJhakxmCe1tH7Nyf4pXCynm6pUgLzoUBaIFVPzyR2+oFCzNHBxlFpkmdW5jJC7kwkztN6Qxexh+YEYay8DhvsJViklhmiV2Y0crhqQi1WpgR0i/MhJXm/TdP2C7DhZmdmqT/xCXORQH5wQ5HU0c2zhdmxtt7HN56j/df+TZnLl3gzPpZolZnYaa/sjw3UxULM6IoF2ZuvP5HaF+ipV+Y6babzCYT8koRBNHczGS4MLPz3luke4dEoViYiSoWZu4Opzz1mbM8+NObCzO3/+A+Q6UokCzNY7Y42wkXZrwXHAnJMJ9Hi3jv6JZ2YaYZhxif0u80FmbeuP2Bmc988gJlpTltPjBzL3FcfGIF2w25nxWcOt3mytkPzORpSmQ0Dyb5B2be31uYUQiEErSEXJip5Ic/nvzQg+5/9r/+3V+2pcZnGWGoaDYMgdH4KCQ2kiAOUSqg0W6DFoSBwQF4jbMlAk2ZWbJxQp47sqLCmDbDQcrxxHJymJOWklpdsdquozWYQKGsIIwc93ZS6jqkvWTwYUCrtUQ2m3G0MyHoKoJIUY2mbD8aUW/F+GLA+Wde5PDedcJOj6geMjoecfrcVe7ffAdvWrz7+nfpdTscHe7R6a0xK1LKvGLl1BnGx4+wZUm73QBj+MjnfpKb338THURE3R6RDjg+OUBKzehwh17/Ag/efZ3th49Yagm2rz8g6HcRaUr3bIuNjTrnlrqsaMW1Nx5xd5IyzBXvv7vHUVqhpGPNSlzXMLCWMnOMvSPEs1w3bGy0WT+1wvHOMSPlIQP3uMHlJC05HFaopCREUswcSMGS16RVzsEgpSkq+j1DGAqCEk5vhDy4PWEyUbSamhUFSZ5xNLY8d7aGHFqgor3Uoi8LolDSkyH9zRa7oxldHZFnBbHRlEXJSqvO1sGY2b9WebrRVygX4LOMdismiv4/zu70ybL7vu/7++zb3e/tvr1v09PTjdkwGAIgAQIEuImiSVFlx6JJJWVZqqhkPQjLiWwpclJGylIpVbFLUZw4sZioHKUqtiLZimhtJMUdxDIEZgYzg5menum9++77Peee/Zw8aIRUHpCp4v/wql/9lu/v8xExFYVYVzEUET8OUFT9PTMqmiohywpxAkkckqQiUZDijxzCSMD1A0gURgOf3jim2Q/wfJGZkk5O15BlzrJ8UglNT7h76lDUdZQ8oCjkchVah10mfY/q5RmUJCEaTrjXGJPPaKRBF8ceoCoyU/OLuCOH4XBEp9PEGfRJlRzt+hE5y8T1JliZIk7gYk96zK1uMurV8OOAYiGPh8CzL32andu3iAQJq1RGCHyCWCAMfHa3d5hbuMDRu2+RximG6nNw0qZSnUJwXRYvVFiYz7JSKRIGEY/vNGnFEb33zKQSJELCbCqRFmS6UcxoAmPhzMzaXJ7pkolhaThDl6GYICYyqXhmpu1HtPohFgJawpkZREqcmem1HDJizOJTC4iegxpCJQu1ownDQGC5JJMHPD9g4ERcWTYJ+wmSEJMv5ZiSQ3RNpKBmKc9mqA8dvMRHCgXyhoHvekznLPY6Y3711//rH3rR/SMXpd/7nf/ulXHkUx9E6LKJKQcIiXgWlemd5e94/TGuO0E3cySpBWqWMAwRU4U4Cgn8BJAQJBFZlOj1J0QxxGKKrmnstxJmMzIzBR3ZMlBLFe4+ajM87KOEMYIbYRoq6y9coXW4S9FMyZvSWTB610HIqizkTEozeSQ5z97br1IolkijAZXKCu3aPt2DA0QtS72xz+z8Kr1eHUmfw5mMyWYzpHFIvz8mCW1Cf4Kk6KTZKSJimgfbSGnM8e42588/iT3uk0ag6jq33/wGE9tBwWM07PPV1x9T2xuA6JMhZfuwzVs7PTrdCRNCNMtgzVTYymgYloAwijlRRXp+RE5Q0YSYopLBzClsvfwEmeUiYhBy6ZnLTCsCW8+tkBUNnGaLq5uLFEXojSc4ioSaSdBkkbobMm1m0SYx+RmDU9fHjRWsrMq46TOMBAIxoIDK0vU1csU80yp4gkhpcQ45ZxKMhhwO47PiQtdFdMZki1nssUc3DRmEAkVTxhQknDBg9Nd6vNYqeezQoz6ImDV10sQ/ewkT/l8zIcHAwXUnaFaeNDFRchauGyCmCoHrnh3zFYkwPauVdifiWa6UmBL6MrVBykpBp2DJyJZBJ8pyWO8zPOyjSyDaIaVygdVnt2gd7lKekikbEoE/wUAmkVKKWYXZahFJzlOuVJAQcOwuVjbHsNPAUhWS1KDe2Of8xWvUjh/TH3pECWdmvJSh7ZKENunERdQMzm89R8fu0jzYRkbmZPc+fuLhd0coqsF0dZq3XvsKE9thMuhjOwNu3m9z8rAFoo/cjtjtdHlrp4dty7jJhLnVWappzFZGI4pCFB+OhRRnEmNKGnoSUdTOzFx8aQtjIY/pe6xfWWfe0rn63BNYgozTbHF5tURJUTj2PEJBQM0kCCk0g4hpM0vOS7FmdJojn5GXYmVVhuMEOwA3jSi4KQvPnEdRQhazBp4gksvl0acL0LXZdyJyUyUSb4hgO2SLWdxRyFCIGXoeeVPDFCR6bsA/+sc/5qL0xd/+jVdkQeLES5jXBVQpxdQFxARCIUQWZSRTBUUjCAKMUv5sZslPSKWz4PogjBCjlEgIifyY2HUxTQXDEClqMioJiqowd2mNN26eUNVjChpoBRGznMMq6CRKzINvHnL5Y9d4/LiJrqaoikSogCiIRGmEPpUjHnXQBZHxwCYKJJxeDXc4QJJVzl+9gtMZ8PSHP87tG6/zxNWLOH5Mp9GmUi5jZbPY3S7uaMTsxpOYcoba/beZubDF8b2HTC/N8vjW1/DHI/JZkXr9kObpCRkp5J37TQ4OeiyWZNbnsxSEhDv3HBqBy6dfXmZOlDkYBbgTByeKWF+bYXpR4+jUw4/PspLFKEFKfDbmC2x85EkGJ6cETYegO2DvO4+YxC6NnS7L1+ZJTkfMnp9iPByheTH4Catrc5iCTHM0QQxCCgWL1A3wBiEXN6sMjwe0YqhoIovZhG4cUliYIRnbjB63SFwZw9DQsxpRxyFMYkZ972w7Pva5fPEcejAhoxv4aYiTpDRGLp4g4oc/2CmtFBREBE68hIIMqpiiSRESEqEQIqYiSkYHRSMhQstniYMUIYxJpYQkCUhSEFORQAhIvPgs9VQRMAyRvC5hiSmiblLdWuKNmycsZaBiCWgFEd2wyFYMBCng3tcPuPyxa4zqLVISNCAIfARRQpQU9LJJPOowbLfxxi7ZXI5+7RB/PEbJm6xtPIHTGRAh06wdcfV915mEKZ1Gm8JUnlyugN3tIikJpaWLaGLK/jvfY+bCFrXth0wtVJnsnTLuHzE1lWHi9tl//IiMFHJca7G90+Wp+SwzZYWCkHDrcEIn8Pj0y8uUOzYnUUqr12ESxKyvzVCYkai3IyYkpAqIYcqioTNbNdj4yJO07z0m7PsMHtU5fdDEiyYMOx1mN2dJTkeYVpYw9ZB6AXKUsro2x7g7wklSxCDENGUIEsKOy4XNaYbHAzxkcgosZCS8io5VKuHXu3i1EYkrk5/Po+oq3Z0GgiEx6ntMUpm9scfli+ewXIeMZSLqMgM/ojFyCRD59f/qh6cE/Ogyyn/x374iIeD4IVNSjKrIZDICpqGgiyKiJKHICYqkkJuqoGWm0LQp/NgjcgJEzi65FUMlCjwUQ0HTxLMGBQEyGdBTiXGs8GB3zMX1LFE0QZAUBE1jMAjRJYFaM8SwUnwzh9AeoeopYpygpBAjUJiuMDUzTRhEFKfmIRGwjIR+b4wmiwiiz6OH25QW59h/fEDqpdx99zZraxsMhg0sQ2XSbxAmEUqaYupTWIUMnTjBSkyyRQnftrEsGSmyeXf7mKDTI6PrhJKKIkX07YiNSOS05vKw5+CLsDZfwBQkJh2XmhNQVkWcWKTdHNHaH1FEXKGhwgAAIABJREFUZXbdxB76PPvCMheuX2D3UYPunX0qa0tIkwnjvSGT1Cd2U0wiIk+iemmR7W8+pFjJoFUK6CWTXF6kuX3CBz7+BKXCFElBodecME5iBu0hGUGi6QVMLxssvO8aC/MlRoc1dF3AG8Qkkc/pcYeZC1UCP2R6scrc3AxVQ2NpeZrQcwh1jaN6hziWWZ81UIYxZU2i4f3gjmC+pCGlZ2YW9RRRlJidNZAl6cyMIqPKKYqkkJ+aRjHLmNkCXhgQOQGaIiGKEqquIZIgKSKmqRAnEQggCyJ5VSLRLG7f73FxPQuhiKCAoGmkvouIxN09m0JBxDdzSI4NJBiIuImPKMh87hd/gWG/QxhEPP3yCwyaQwK7jhP5aCj4Q4e93TMz7959i4I1TaPVZmZmjsGwgSLoBPaZmbNvK3l2dt5EmF7CSkxy+QjPnqBls8iyz8OHxzinp5jamZlad0wYQXnk06x7POw5BHLMubkSpiDhCgn1vs+yKtOPBNrNEe1TjzIKcsXEGKY89dICxfNTHB506d7ZZ+H6FulwRKfpQCAS+SFZTcEbJFQvLbL/YJ9SIUNmcwHdkMnlRTQv5ckPrlEqTBHlNQZtl0YYMu6cmTnyA6qLOsvXL5Er6kyOGqiKQOQKJJHPYWfE7EoZSbeozJeYm5tBj0LOn58n9Bx8S+W43sUPBM69Z2amYPCLv/KrP96i9L/98994RZElhDimYIClQtE6u2DUygaSJCFJoJkGQeAReB0kJSWbsTDVlDSZIKsKYeiRK+QQ0wjNAE0VUX0fIRXBk+ig04kESlmJOErJKhKKZlCpmGTOz7B+fo6DZpOy6JHXBAIhRkXD0wKkJMfsyiK+mqeYVchYAo2TPaJYRFUFREVAjCUkU6VrJwS2zTvffYPJZMTcuWk2N65w89XXcP0Er9dGzGh8+mf/Hjf+6k/wHZ9yxUBNQTdUioUKdrfD6LQFiohv94kMiZ/+mc9y+rXXMGYNqst52p0AKY5Yz5lMTm3u9oZUJYFzC1lMX6Ceephmli4xB4MAJ0hID4bY+03mLIvcTJbG9gFmsYQ/Dlh7dovBYZ9RGNAIY+oHNZKKQjiOiTsDFp6ag1DCEHR8MeL4rQN6I5uBG541UugStgnlksnQibh3e5/9wy5TJZXy7AK+4GGWTaQwYLTTYSQpBCc9+odNSptVBjf3CRGRlIRMIlAwDB7Vx6R6SiFncTqc/GBRskQURUaIY2Y1GUVJKFgiinpmhihGUSU00yAMJ/huB0GAbPbMDLGHpMq4ozEzCxVi3z9LLVRSVN8nDgOURGOcWeB0bFPKSkSBS1aTUTSD/HIFa2mKS9c2ODg9pSx6pHFAKkEqi6jIpILFa298k+LSFsWsgtdr0W4cIakmqmAhKAmWaYEq0rUTTg5qnG4/Qs1kyVZENjeucLL9Dr2hj9drIxgJn/r8z7N95wbxJKZcMWjV60xNlRH9HrHrMa63QYrwnBGRIZEtmmSOexizGrMrBdqdgJlQZC6vMzm12W4HTIkRaysZdPfMTHmqRDMMGLgugzgmORhSjCRyqUBuJkv7ziPUUok4ENi4Nkf/eIwjhJzYAfWDGiNDRZxECGGfuY0ZCCWitk2oixy/dcCgP2LgR+ikJLqCbUKlajAYRdy/e0LzZEixIFNcWyPizIw8DBg9bpGKEuPjLv3DJuULC4zfOSBERBcSTASQRY6bLqmeYokiv/grv/ZDF6Uf+fftIxdKqSDKqMMJxVxKQUsplCXy0yqmqWLlFGRVQo6Ts655WTsbjS9m8ZwRmUKW2E9IRNBVhXZzDzGIkWSDyAmIBYkvfiU4i9Y1LB4fDNma0TDUFDcQUGNIhZQwiYnlFBEBIUpQFB2A/mFA6bkVioUq7vCQ1eUV7JHDyf3HmEWLwJ1QyKroVoFB36c9spGzJTwlw7npIrX+iLzkcfvuQzZW55HyOeJJzOL5Tbr1h5w2ba49dRlZiDl/foP+cMDh7TfoNvo4jsPcbJ4kX+X3//gtMgTMzudpNiYQpkiCzKoSUb00jWsHOAObUnWK0zsn1CMBJU0JVJHzhTzLz6yTmTGpv/EAScmQ9G1yV5Zw6k0apz2OA1gv6oiGerZFtgWiyEYcewhyjJeYWF0HvayRX19EVBVO3rhPabpEaug0HjdoKSJTeQFRU8hOZxkMQ4pKlt3DI8rZDKtX5oidgO5RnepUhaEv4nWH+KLDdK6KK7g8uN+gWCwwnAzI5zIESUynHdCyf7AofWyjSPKemVwhpqwIVGck9OKZGUGMyJUyyHFCLICmmRiGip7R8ZwRVq5IEgagyqR+yGh0ghD6yFKWyAkIhIjf+4pAzjTwDZXHB0OevlAkdh3c4CwLWhEEkiQlkGNEBHTh7PAWTCKi2MTarPC3fvpn+LM/+X1Wl1fo7j+m3XTIlTVSN0KzZETDZDJMaY9sFi9dYL/msjpTptEdkJc83r65z9bGFFI+x7tvb/Oxn/o0w/p9Dpsu1566jC4ErJ7fomtPaN56jXqtTZJGFPM6Sb7K1OxV/tW//J+ZqWZodXwIU7QYFg2oXpo+e6nsDZFTmXHLoR4JTIgxFJkPPXcJw5TR57I039xGkC2Svk3x+hqjo1PefLeJqgmsVDJIcgI5i5EtYMgeTttm4EcYhoXVdahenQXdQlQV+ocNtBgEzaK2d0pLEVlb0HGChOWVaY4bIzJyloPdIwrFMzOymaH29rvkqvMEbojXHSKaMllVxxVcdmt9LMEgjBwUXSNIYk4aE4YT/4cOK/3IndK/+mf/9BVFSIkCh2ldZqogUM7L6DpYpoCeN1HVFElVUVURUZygqDqmaSGIAYHvky/oRCJkc9NIfh/CkOnFdeKwR6MR8CevR7j9MZcuVTEJyOs6iaJRv9OiK6ac1j36rkhRVLHyIkGaoqWAJ3Dug+9jKl/mta98l77dYTBJUZw2Rgq5bIymm5x2eqiywuLVi3zv7cfsP2ogKx4HRzXkYMBJu00xX2FucZmbN7d59Y0d9h9tY4gi15+9jpWZpVyt0Dm5S6mywcTp0el0Ka5USL2IBzf2QZH43M/9DbJKyqPdIQU/YW1aozSTR49kHE08e5V0PNw4phSfzWBVixaFGRNldQGGfYanE9LuCPPyImpG4ivffcxCTmF2vsRw5PC44bA4L3PjThN7FGIHEXOLZYJBQGoI1AZDimaGxo0HrH7iGndefZcHPYdBnHDlfWsUMzqKFCAMA9SmR261QEFIKQiQZM7iYJvDMeOWR6IHaIbGzt4Qo5hDrlp0D7oIikTfCRHHAYKi40887L9WLjibVZBJiAKH9YJG3oJSXkRTBSxTIFPJoKkgqSqaJiOKE6JgQi5fRhADVE3BMAW0jIlRKCB5QyxVpDizRhz2eON7E779LuhixNpaEZMAI2eSJDL1Oy06qUK96dAcTyjLGay8yMQBTYLwdMLqT1ynalX42h//McfNOoNJypSRIPkRhdxZkkC9P0ZVDZbeM/Pd72xjmiHNbgfsDiftNgtzZaZnl7h5c5tHh0N2H96n3Ql4+cPvx8rMMr8wRf3wHoWZTXbfuYEXxczMzxB4Hg9u7PPlb73Jz/3SZ1C8gP0Th4KfcHUmhzmTQY9kYhFCUaAowChOKMUikSyyWDCZWi+Rn68y6XboPe7D0MG8vEgw6fPNW6dcXNJRFQ0/CjnsTJifU7lxp4nbDxgEIZtLFu4oITUEut0RpqLRuPGAmUvr3HvrAe+2RgxJufK+NdIwwtIT4n6AOo7IzGeoWArZOCbJ6HQaLTrdIf2Wjaidmbn9sE6mVECuWuzf76CpIu1BiGj7CIpOGKX8w//yhxcH/Mid0ovncqmuqXj2mGcrUCkoWBmZTE5At0S0rISeNUCQkBUPTSkQywmqKBCFKZKqoEoSaeAiWjlWnriKJxcYNQ+48Ze3+atX28zk4d6xSLWqkDm3wv5X7zG9WcDuRmh5kTTWCcIJ8X7I8uc/iC5M6O3tMbE9EDR26g4XL80jyBYfePFFbv3FlxClhMryPEG3Q+C0mL76k1x4/hP8ky98AQuVw9aAieuTtXQczyURzrJh4gQKqoYXBUgEbD61xec+91nKWQFn2GMSKwzr+2y/9SZ6foqvfWsbR065MmNhlqcxhi66lrI9dKmfOOSShEvXq9j7Q94d+KypMtZKlp2dPl6acnnhbIjsfqPD85srBP0x5WvnaNWOCXsBh70RkhIwX8wzEi08zyMrJ/iSzNFBm6nlKnlNRrEHnEYy8zLcOfG4tpQjbHuEpozuR5iFHOOhi5gJGYwDrGmV+CChenGZwWhI7nyF0U6duO8jby6gigm72/t0ewFeClEakxNTPEHhqa0cUjbPjdcOUBKYEuAd9wdRFB9czWDoGp495vmqQCErkytIGKaIbonIWREra4IgoWkpsmSQpjGyJhKFKVY+RxIEBN4ILVNk5eI1hPwmzb03uPGXt/mjL5+yOadyczTNoj4kc26F5tf3yJxXsbsRekEgiQy8MCDdd1n+/AcRJw3sZofYi/EdhZ3+iBdeepL+YMIHXnyRr/3+v6YyU2D9+pMc37qNkA5pM8ff/OVf5Z984QtkE4X9zpA4jFA1BcdzQYIoSokTKMsGTuLxxHoVIZfhc5/7LFkjJXQGjGyPkwe3aJ7WuPDM8/ze734JR055eb2Eq+XJugmy4LE9dDmsj6mEcOl6ldo7fY6TkM2MgDJXYGenTzmSKS3ncQ97nEgxz1xapXN6yurz12jVjvH2bU5ij9lpjTSR8GSTUd+jnD0z02iOyU/nWS0XGDdOOI1ksr7HQR+uLeVwJgFCKpJJU1TTYjx0CcwYz/GoLGRpvt1m7f0XSawAMhajnTr9pkPpygqiPeSw1qHbC3DSlDRNyIkprmhwfdP8/5hZKpm8ftr98XZKv/fbv/WKLEBGNQhHDitVFdUCI3PW3yYrGrIkokgJimwhIKGrJqlUgsRDkxIMS0dQYDIckZt5kpE34fbXXueNGy2kIGJx1qRSEGkPVAJ7gFIQibUCogaBHzKJQ4RawOKnnmb/zYfMrS0ziRz8loueLZMTAxJDYWi36TZqECasnS8j6yqSamBMP8Vg0Obo4V2SyGMun6W6PE2nPSSRfCISlFRCkuGnLhZYv5Jn5fwsL33yo2yuL5GmCYVCCXdg43k2XhjSOz7ATxNiP2LNyDM7VyJVZao5E79qMj23gl7J0Gq22Dg3QzqVw3Vd6p4DrZAhKRNdpjMIUHseP/HzH0cr6XidPt7BEAyNysos39tucGnWwI/8s688hkHkeNzZHZCmEoqR4oYxI1tkYXUGxRlxOnS4sDyNuVpAIUXK5fDaI3w1JlFDkj6cdj0eCwmToxOuvrhB60GP49oQc9FA6YfcuLPHymwV3bfJFA2GboyXgB+GSILJ0B2gJxqjKGIql+PUdr5vZrmgI71nJifFTOVEzCyo5pkZQzeRBOHMjGJCKqLqEqk0DYmHRIJhnR31xBS04ibd2ja3v3ObN260uLSaI6uLSEmAM1EI7AFWWcWTLUQNQjfCiUOi/Qkrn3mG/Tcfsvb0JcbOiFHbxirNkhUmNNs93GREt1FjytBZOFfCNCzM6UXk7AYpEae7D0giD+t4wNLT52mfjIlVj4gEOZG/b2btmRIra1Xe99GPsb40TZom6ClEQUIshURBSL9RJ1Z07E6PNSNPEofoxRwry7PYWZieW0EIY/rOiI1zM8RFnTAOOewHCN2AISlOGlObxJR9l5/4wqeRcxrpxMfbG4ChEWshDxoeK/n3vgSFLoopErkhd3YHBImIqiU0hy725MyM4Ni07AkXlqcprk8hRRFyIcekMcRXY4yCTtjyqXc8dsUI96RO+dw89v6I49qQ8oKGPIx5e7/OyvQ0um+j6yJ2KOAlICsRSaSjExH7AqMoYiaT4e/9gx/+IfdHLkr/+//0W6+ICAiiwmPfJ5sI5PQETUhRlLOyRDOnoukGQqqgZFfRC09x/uX/htFQgaBD6DSRLRnHkXjru68zHATs3Dwir8PF83niCNLQ517DJwlDhEQib4p4o5ThTpOinCEzW+TgjTtc/sgWx/d3uf16k7lYo/TkZeQs3L1zSCWTYzYJCNQQRTTIZLWzvnungRcm7NeOyWgKXhzy8LBNagdc3cyy4Yc8kS3RCSLqLY/TVkS7b0AQEPguz778Sd756r9HEgKUXIUo8OgeHNBsjHnhJ1+msLxA6clz+G8fIUcS4mlE//EeRSniyefPoxgwtbrG9s19JoFMtqLxyc9dZ7maZ/9RB40E+84R33xQ43AwYjoKWfvgk7iNFlYQcbM2YW2pQG62indSQ15Y45zqMw5chEBm2PexHYdeo0t75LNuGhQvrtOtN3DHA0yriKClFFanad1pUVoqUD2fZyszS64o0zjt0W3ZLE4ZJHHE/m6HRd2k+r4VRjt1XElg4qdIKWxmLCzdJ4OF4/kUooRQTGlN/O+bWZsyENIUQVR4+8Anr6ZULBEpjVGUEF01UE0BTTdIEg01u0Jm6TOce+5XGA0VEnufyO0RpD6Pjwbcf/sWh7drHB0NyetQzoKAhCBKbNfts7ZeWcJUU7xRyqQxIhfrTD23xu6Xb3D5I1vUvvsON9/qMbe8RGlpHjkj8NqNPZamyswmAamZhRR8r0M4HqNGPSQ9x6OjXTKawkRX2Kt1idwxT14osOGHbGU0OoFIveVR1jLc24fhsEca+jz78id595t/gizFiNYMcRLRPTzksNbnhY88T2F5gZmtZYL7TdzxEPUU+o/3uLAxy4Wr8ygG6IbF4W4HJ4FcWeeTn7tOoaJyvD9iShS4/foj3tppMqr1yXFmRg59TC9mu+OwuTyFPl3G8wPk8iznVJ9JkICfMh572PaEXqNLIBusiCLFi+v4zQ6DQQecAKVgUlidxm2MMIo688+uMueKVGYy9A5a9Icei1MGw57DaW1IIUhYem6D0U6dZpiSpCJSChtlE0P06I98kjilECWcugH/xa//8OPbj94p/Q+/9UqiJSSpR2ac8E4nZKpgEiJiFgzMnIKsJsgpyHJAnI6JnD0Gh/+GcHAbO2wSGfM4gcDB4zZ+V6S130MzFC6taURpSpyGCIgcHE4gcBERmIQxCAHz738OcbOI/e19rE+9n5O9Y2aKFnMrRYS1BRpvv029b/Opv/EyE69FcW6GYDLg4jMvo+emWL72DKXSEqpl8ud/doPnn77ISX+EKikM7CH1RsyTzy6g6lC1RIbdiKXNBTrdFnPLi7z40ZcoTK/QuPMt4jCk367ROqlx1O6gGgK33j3gpZeeY3BUI7N5jtrxKVIyIZkM8Goe5QuzZJeXEVOR7722DaLAhz++yr1dh8O9OppmMP3EDMb5GY6OjrngwvrPv4zf6BHXJ7jdPuuzKoe7E3ZqfbqByrDX57gfM6sp5PIaK1c2iXebXF2pMp+rkKox/aMOmqQwvb5Ce6eOuTRF9+Yx2RkRyQ4Y+SG+lOHuTgMtPGsaFkoy45FH4kIy8vDHYw4EkQVRYvniFPVTm6EfkkgJrXF4Fk5nCpiqRn30g4vuC9MWnhySpB4VQeZm02V5TsMOzszopoCkxsgpaGZCFA0IOjcZHP1bwsFtxsmEWK/StxMGtRF+X+Zwb0S+bHJpTWMSJIhywmiY0mzYELikiYATRCAEXPm7n8ItKsg7Q8QPXORk75jqYoHZhSJ1Nya694iT4Zi/9dmXcN0uxbkZpuZKzJ+7SGyazK5uMb9yieryKn/0B1/l+acv8rDZI2foDNoO9c6ZmcZOj421HMNuhJ/VGI8GnL+wyvMvf4jC9AonD75K6sOjB/c5Pm3THnSRXJvbj0946aXnaN9/TP76RR7f2cVUI5LJgPa7Laa25skuLzNotXm43aJgKjz38gr3dh1ao/isrXqpRGWjSK3W4qlymfmfeT9+o0dnr0s6sJlarfBop8vucQ/bTuh2zswUlZhSQUc185j9CVdXqsyqGokK/aMOZjVPcWaWzv0OmfUZujePscopDDwkSebh4SmHrZCiCNNz0wglmVpvhBYrGJHIZDjkQBDZLOdY3ChSP7XxbR9fSpAlDcEP8UwBMYYv/NqPuSj9X7/7z1/xTn3EUEcXUzarIQ/2fHRFYxLA2AE30RkGCpNUo9MJ6Q4dGrWY4QQ8W6R/3KF2v0UyiTAKKRuXp5mbihh3bHw3JY1ias2YgxGUCyaiIiLFKZquEHaOWL5yjcqzixSTlJULZaiucfKVN1md15l/7iqz5Rxe4jK0A3RTY356ns7hLiPbwYpt/DRFW7pKag/ZfOp50tpbVPyUy/MyFz5yHdwJvfsdchWFYlblwU6dVpBwYX0dzdII3QFW0WLSO6Xb7VJdXmP71j4njyN+43f+KV/68z+kMjXNozd2ME7HmAUDO5wgDBK0DR01b5D6KXfv7fOJn36aycEDpg2Fck+lPJtB2D1ECG3WcgqJAKPv7lFeKVLbO2Xrsx8hr01RP9nnJ3/ho8T3aizM6My5IrOXK7RudYkbHdIwQJQCJEsiaA4oX9zAvVejdHEWBRG3HxGUUqbXlvFQ0CIDbVknPGqgGjLF5SrH3zmktJhHsn3KW3OMTmpUSzqxDPXTAb4msF5S6AUichKydWmBVFRoDm2Gkx/MKS2XNMJ6gBjqWLLD+amEe7sJqigzCUDRsnQdgWGg4IkmraZPqzui1UwZTmDSDxjWevT3hnhOjFVM2bpeZLF61oyRxhJJGPPgwKMTiJQLJrIsI8YJmq7QfnDK2uUnkJammCJi5UKZUDaofes+z7+wSuEDV5gtmIRpwGB0ZkaJfPonxyjmFHZ7D9XKMJ74yKLC5lPPo40fUJmEXN8ss/6hi+BOCDtD8hWdYlal7Uoc98bMzeTIFEqE7gAlnRBORsRRgBuGtI9GdOshr/z2b/KlP/9DsrkSB+8cMmn3qJby2OEEZaKgriuoeYO4PubRaY/PfOIq/cMdpg2FQiOmMpNFa7ax3JTlgkCqSXT/apvyShEsjZUPv4+Tbz+kMKPy4c++wOirD1g+V2DOFckYKaMjD9WeICQRohQwCmPEoUP54gbD+/uUz8+SpgnhOCUopZQXFvEEhVgVmV0pEpx2SHSF8vIMx985ZO3aEnRtZq6t0ts/olrSSRSV2lEbXxOYKVmM/BQLibXNKqmoMBxO+Ae/9o9/zOHJ//43X1HzOuHEpWoEGInM+pRMpCeMOwmRE+KMJ8R+wmTsE0wigkmC23EYtya4gwnDRkipJLJwdZa5RRVx6OB6Lm4sICQJjp1SHwu0XIGMLCGLAmkKkiWRyHlKF9cY3N4jt7FKOB6y+6/fZP2nLmJtbcLAJ/QGiGqFmflFnnz+M7SP71B7eEhZCWicHNPqd2jvPkAxPL7z7VdZmjIIWz7jA4GRJfLNb5xw9ekyJ6/2WblWwu25PPH8dR7uHXJpY4VSwWBx7Rz1g7sU5sv0Oh3mlhcIewP6/TbnCkuMPI+CMiGwPUa9IVdefAamfcrX3kfzboPm9gFzCyXmprJEoUE0BFmVGew0GQohpSdnaX6nx5WPb1HaWqCzd8L89RV6tw9xVI9ClKG8vEjiOohmSvnZ8xi6xuC4Q2UzS3jq4vgiuY0C6x9+H72jYx7URjy+f0xGlnBrfW41bLDHHDS7eEJExpKZ2VqidrdNoEZMl3LImoE6l2XsOHR8j0vPXmZku/Rsn3NTJkNXYEqH4RhC12X3dISMwsj/wfHtXFFDKpyZWTJM5Dhha1bGU2LGnQS7M8EeO8R+wqjnELoxvhPh9dwzM/0xo1bMzKrO0qVZZuZlksGQwI/OzKQCjh3TmKgMAsjIEkmcIIgCkiURkVK5vIG0vYe6vkI4HnL4Fzc59/EryHPzZ/Gy4wEpWWYXV3ny+c+w+/bX6NV66HRxWmPawzaHRztks/Cdb7/KLBLJOECIoRkkfPMbJzz9gTmOvt1l5VoJUli7vEWr0WXj3DKlgkEaRnheF0GVuHT1CfSMiXc4oGd3OVdYIjNbRfVbCIcdHD/gyovPoF8tk18/T/Nug3du3ueJJ5YQExtZqxINQVRkhjtNoqpBbjZL/c0e55YXmHr/Mp29E5aeu0Lj23fRZlTSHYe5y5scv7tNcbVI+dnzhL0hoR+Tn9ZI+yGOL3Lx088we339zMz+mZnp2Rz2XodbDRthPOKg1cPKFckVDUprMzx6tw5KwnQpR9i2MdanqB+eMiDm0rOXOTk4xI5Ezk2ZyKFAVk3Z7gRI3pkZS5b4z37ETun/9/UtDENMPcsyNnkhYHmhjCKOUS2R4rzFJPQZD1JERcUoy2TRiaQhhiahTkTk/CzxYIhaUkmDMW4YIckCzjhm0Is47SQMXJEHXSi/16oRRiBqAkog824n4nO/9AKDRx1Ex0GuzrH/6jZ2UUG93WbtP7pGZ/cAP6ty7tI53FHAwvoi48MHPHx0gCJbDIIAI1BZ2cozEqvc/No7TBUEUllhpx4gjFzSOOEjn1il144IsipDW+HyuQI/8flf5vZ3v8T8zAqzyxeIxyPcJOGv/uwPeXx3myfEBQ7rp+jvX8b96n3kSxUuX7/ARPAYPDjg1PbJpDLLH/wgDCfsffk11j7/IeoPbzOzfIFbr+/y+GGNtfGQqz/7USInhDTi8Ou30JdnMIOYcRqy+OJl7n7lbbY+9Rx/+sWvsqhLbP3Ms2hA5IzoHHSQl6ZwbrY5OW6xS4AgKsRxTMkUEKQEMdYozGSInTGHXZdqVmdjaZ5OvU2oy5TmLILDIYoh8/begGxGpDc++0ISiyoxIWosU06hRYQvp6xlM9yt975v5mNbFca2jalnWU/GmFJIVo2pzhiolkh2XiUIE8aDFElL0IsZFNdGzihnZsICsmkRn7QQ5wWkOCUSA5JYwhnHnNZdBmOJ+ljgYCi8ZwbCKEHUBNx+wrEr8rP/+afovbOL6DjYA5N+u8FBSeCZyES9ME3zsENkBJy7dA7TnMZ+Q2rZAAAgAElEQVTICBzfucNpo4+hCmf/M11Y2crz6kOZqHZCwZCQLYmdekBoj1FCkY98YpXtA5fCjEXJMshkMvzE53+Zk/tvomkG+akKrf1HVBY2+aN/+Tt0RiOeEBc4ZYC8XMH9i7vIT1a5fP0CJydHiPaEU9tnabZIdu0qdqdP6+tvs/b5D1HOmXRaXb72e68hxiE5b8yl//ijpPaZmfatxyQ5CyXySSsW0xdWufNH3+GJz3+UP/3iV9lcn2bpuXWStotihnQOOmTOLdJ985iT4xYHgk8iqCQJFI0EQUqwZstoEYS9EaeTiClLZm7JwquHhLrM1GIBd6+DZol87/GIbEakY6eIaUwsqoipiJDEVJKYppDiyykbxQw3j37469uPHp5cL6QTLyCRVRZihyeKJoV8jF5QUWKfOE7JZDVkq4JhaQhGhdLGVfLVD+HLCY2HN5BO/wDfS1ALDlnTIhHPerfqhwK2l+JMoOX4PBpq6ImLlCr4UYie1yDV2PjgFR7v7KPf7FH921cx9Cxu5CGOWqT5WaxI4LX/4ybFl5ewhx4np3X+07/7Of7DN77DtetLOI8eU+/YZE5FZl4o8vp3W3QaDrqS8NIHz6GszPLVL9+jXesyF0UcqTKqZPBL/+g/4fDBNj/9C3+fxoPvsn/vbc5d+xTvfPVf4NgmV154kd13H7D37iMu/9TztO7vIOcsGnsB1fmUNDa59a0dZNnlmY9cZnTiYOWmoFWn7XY5uTvkmb/5BF1PIZ70WNg4x7f/l6+TNXRy50uUKhUab9xF3cySv/QEf/5/vsU5SyOYuBwJEUM5QQ8MssGYQJE4HyUUP3CRm689wpbgYz+5gT8c8s0bHZIkZtWSyRUTGo0EOSPSdmJCT0BQoWhqtDoOqSSQSCCFEYkIRphwfrFEoNnUjxKKlsIkiAn8lE6asLyYpdd2OO3/YCTgxeUsQRSRyCpPmjHTskilGiDrBkrsk6YSpiWdmSnoCHKZ6ubHMac28eWEg9f/DZb7FmEYYxYCNE0jlSI8O6R+KNAb+YSRyn43oOar6ImLmMgEcYSe15jdvEy2rBO3+tS/vkf1b19FzWcIHB/NaSMX5hC8lEd/8hbR9RXsocfi+gKXVtZ5cLpHwXcY9Vvs7I2YHcvMvFDk3/67XSxE5uWEyy+cmfl3/+ur+FLMXBRxaopIqcVv/o+v8OqX/4yf/oW/z/FbX+Fkf5utZz/Bja/8PpN+ytxTTzI8OGXv3Udc+amnad4/YPrCBve/u091PiVoedy710GWXZ77Oy/Su3VC2oOMGdF2uwxuDXjiZy5y73sttl5exNDz/N9f/DrL6pkZ+7SN6kaImzmkhVVe+/N7PLk8RfeoyZEQvZcEq6OFDsgC56OE6pUneOOdx9gSfPInt7CHPb7xWoNUFFi1ZLRsSr8TMz1j8U59ghSkSJJGPgutjkOinH22Fj2ZVPEwwoRK0cQqR9SPErKSQiDGeIFAL4lYXsxSO7bpTLwfrzggQiIVEiQ5JhEUAjnCF0Gb+DgkaIKEIIgIic3YBimaoDSP0UoNRjt3seIaHiLFBQmruIzfH5HaMaPeCDdQSIOQQBCQkhBTLRDaAaGYoosq4gCkWRXLCxHeOGT5lz6KKEI8sEHLkGg5xMDF6zmIFwxu3tqnMpPh+laBe+/e5+q1JbK5dR6LR9y8bRMlIetv2RQWcmyqGvlL0wgZmVo4odcf8bEnKvgFC6MzYmPGwn60z3RpEX/sUj88pL9/wP3OF7EHMa4zprpyka/96X/gpNmn87t/yUs/9wmatT1u3dghkUX8xCNMRf7O+4vImSL589O89gffYHYS0IlCOolA+3QPt5ll7aX38eZv/3s6GZmSItO6c8LGP3ya0so0vUGXb3z5PplKSCIrSHmZmUBj0hnzwrN58tllxoLM22/cJ+w2+MBnr7P71gPMJOTd3T6kEaIAh3bAfDbLzBpEUUTfcUgEjetbRYLAotUNiKQIRZDY1EWEaZnhMCGNJ9RbEuvnctRORkiGgT9JmC0lzM6WKBsZTvuHf81M+n0zgzSgIMv4iYj0npm8pX7fjOfKJExIqeGFBUY7dzHVR+CKTK1oWHKZsWPj9keMRgluoCAKAoEQYEgKpmoQ2gGBkGK8Z2YuB4kX0p2MWf75Z8+ilBs9hHyZQMkwqbXQEtjLZum8Z6b0eJt7ToAkR1x+4UP80Ze/xJ29Dg8ShfW3bM6tGKwnFtaGhlyyqIUToozMx1aL+AULbdRhs1Rk99ar3zfTOr1Df7/G683fpXfSR5AtZmZXeOcb3+Kk2Sf7zV2Wn9vi+Ht3uXXjlOT/Ie3On+y6z/vOv89+7rn77bv0vqMb6MbSAEgCJECKkEVSIiVSGy1FshQvYye2J7Ez5ZpkbE+imYzlcTKpTFU8juOSF2Us2VpoyaI2iitIgiAIYmsADfS+b/f23Zdzzz4/NAss/2D9oPkTTtXrPHXO93me70cWabguCD6fPZ1EcnTiB4aYvzlH+d1l9lyHtqpT2FxCtz10534u/de/QzF0lPfMnP6tjyLWbQJF4EffeoNI2mGltEuia9/MUrHNow/EiUb7aQoKV96eIeSX7pmxfIeFxTKBKCAKAasNm4O9WTpjJpILIdnHcwLuO5XGKgfkizai44AmcyQHrmFQrfokkhpr+YDRkRg3Fmpk4iEqDYuutE5XV4p68f9HxNJUVgsi4RCBZXGoQyEW8YkqLpGISCqqoSs+qq7gOS5GNoOk6YjqAJreRbU4S0S6i29LKOEQeirEUnGUUO1NBE1Dj0S5c32PwHIo1H1uF0Mojo0s7t+lbGRVRh89y+pfvcnks2eYX1lCXaiyV7JY6ZDZ3naQ6jVsHWRP5IlHexDaJtOzFsneNN1iidTQGC++dJdqy8ZxHJRAIEyIAafG/Y+eptRrEg9neWPmLps39nj60X4atSYZLY6ZgNnrZc49MYBJCGtvg0LepnOoHy9qIAshZm5vEg5VCBoOV2ar1HZbeLKI6ohYcoDvWXz8eJrBU6eomXVUX0IOxSncXmbt7VtYpk00GuY6PmM1D8ex6T3QQWmgh6HuFM22hxr2eefNG0i+SCuQET2LRFhCcDRu7VTxXcilFRotl1SHTDTbQWqwh53pPLYmsDK/hNv2UTyFnsNdLN7e5OHTWazrNYyDMfxYjL3rK7hRibktG0/w8AMBVVY42AEuAgE2cSOOrRusb2wS1zXCCqyvNylLMpXm+8hO98eRRAgsi+MpUKMSMcUnHIFUVCOkCSiqiOe4RPsygI6s9qHoPVSLs8SUNdy2haAaJMYOMbckIddeQ9XC6JEoq3cqNGsm6yWRxZqC4thIuoTg+RhZlbH7T7D8rasMfOos22uLqAtVXAKuCz4bi2XEQMRXXUb7uhgflBHaJot7YdSQyMG0hNgV5eXvLVA2XTzbQgkEtLbHiORz+rc+TqG4TDyc5U//5iUS6Dz9aD81s0JOTNNSfObmq5x7YoDdPQGNPZptjXBnJ+gSzbbA5lKRcKjC1lqTrYJJyHLYaniojkiAS1tw+fjxNJlHHsKrVPBWK0THhincXmbp/M395OD+HHtyk/SiTUO0GenfN3NgLEd1r40V1NmYXqHl+oQ7eylurJIIS5RLIlvNFpInkuqQaLT2F9C7JzpJDfawdmsdFJ2t1Q1atTaKp6AlVaqVNk8+NcLaq4ukx7L4iRR7VxdwoxKzmxa+6IMLsqZysAM2Sja5lEDciFN3LfKVFhnDQJE81tebNPQQ+XLtZxuetOf+4kunjqfJqgGe6SJJ+/MmqqphWg6KLqHoEpIu4vkWhuwS2LsE1gqilwcBXNlno9aN4zeJaU3UqAiiTCKZIJOV2Fu2ME2JrbZLl+Jzp6bjyCrnnj7NwtcvMPzUCeYvLRENx+k5c4Kdd2fJNnyGUyLzbcAVkASRhaUyjz/7DJHCAtmchGM6REJhLs7uIvs+oUDiuCdw5p89yuDjJ5AMieLVDbztArn+MGOHB0kYnSiD/bT2lkn3d7FXyePYAmEjQnGriarJHH34E4SUEIuzd6jttojLJtkjBxhJC9RaDrtlC0lyCFyXsKhwZ73A0vwKze0CXZNjvPXD6zSvLzPx2XNItsPg5z+IulDCkzyGHhxDOTqKWijQjkt0Huph49IFbqyaBIHEgUwE32lzfb1J0/RJKBIN18Z2PNptSPTGmDw8zrWvv0mqVKVUbXP01BDjJ0bY3clzdKqLlcUtwokQvQOdtMsVwhnYvVVm6NEJ7GaNR48O0dURoatToVCy8ZsuCUditWhSrlv0RhTWCm2qLR8bGUULaJjvX13yPz4Z4+ypLrJqgOi5BEhIUoAiq5iWg6C5qLqKpIuAiy462M11BGcD0cvT9l0CxWe36EMAhlyCkIMs6ySSCXqnPsLW9dsUbYHie2bIDrFVaXPu6dNc+s8vM/lPTrN9cw1DjdJz5gRXf/ImA22NnlNJ1jf3O3iVaoulpQqPP/sMYukOnUmBerNObmCQ199ZBt8l4ssc9wQe+91P0fuBw6xfvIW73sTbLnDuE1P09qdJGJ1oyQzN2iZ+NIzp1nBsgUARaZVcEgmdsx/+RQLbp5TforheIS6bTJwaZaBD4p27u5i2gCQ5SIGALsjcWS8we2UOu1hk7KMf5PXn3qJ5fZnDTz2MJPqMPHEfje+vIGZUJj9yEnG0H7VQwM4YZEdy3PzRW9zZNgkECdlqE5Jcrq83iRkyeiBQxcW2HNptOPPEUbp6urj29TdJ7NWp1iymzh5g9OgAuzt5zp2dYmFpmXQ0hFN10eSASGeEnekdhh6dICa1eGB8gEyPSndGp1CyER2PtCezWjTZaQsMRRVWt1pU2vtmtHDAv/qdn7H7JjfvfikWUQiLJZzObpxiEdsCq+UieQGyIiNJPo4XIAgiFvtRSpZrguMih3Js7EpofptoWMdpbROOxdFkn0a9TKyzi96jZ7nx9nUaTZ/nlwU++/GTHDhzgI2/ukwgCHjJJNZGicvvrnDp3VlSkoboCTjdMXbzTQJRQFBl8ODKm9NslRSUiEF/Z4y53SKlekAyJ5Gve7RkkfV359k+f4ds4JP+1FkyE+M0NuZRQzFe+uEVcuEyTgO+/+ISH7hvgMLuNpYjo8WSpHPdTJ68j69863vERB3x5jxvzO0xfWWd0c4kw0c6UVsOgQOPTsToiWi0igG7tsxQj4au6vQMGxgHE9SqO3Q8NErYMLh6ZZqTnzxL8vAAq994jcipEb7/3UtcuzTD/Gqdnq4Y5ZLAyk6esaEO7v+5QxyeGODK9VX6D/aytb2NJPocf+gY05eXiDdNAkfEbtVYXatR39zBqwvkehPcf2aCwaEurI0ya3N7+J6Fpas0TIkHxsaYvz5PNKvz1pUdLNenLoEpOxiRGNV2k1DTo+ALuH6AE/iIgUTTfj8l9w9//3PEwhphsURh1wbJwzY92i0PyQtIJsN43nvnG76wbwYZ27fBcSEQ2CnHUCIqHbkuWnvzJLJpNGHfTMTP033fB1l+d55qvc3zywKPTEQ4+KHjbPzVZeJdEaxInN1X7nJjIc+ld2fpjWcQ7IBbeyaO7YMooskyvr9vpiWGCQKVTDTJrdvrVNo+gezQdAVaskj+nSVWX5nmzOc/SGhqhMzEONXlOSQlxEs/vEJ3pI5lCrx6eZsPnOinsLtNJJxCNKIMP/BBrHaTb/3kPJ2ujn3zLm/M7TF3ZYv+zgQnTh1AMdsEDnzgaJJuQ6FVDNgTJYa7Q8j1Jj3jcYyDCdrVFRKPHCLakaWhW4ycnSQ81M/aN18mcmqEb379Ejcv32S3HtDdFaNc8snXyowPprj/5w7Rn1W5fmePbE+a/F4BSfSZuv8o71y4Q7xp4jsCbqvOzGYFc3Ubry4w9fgEY+Nd9OV6qFSKFFfqRGSHmiTQMCWkDZNKqUYguVy9XcFyfZSERMW3MSIxDNchqNvkZRXX9XACH8ET+J3/5WcsSuW1H38J30H1XVp7FmK6j+buFpoqoYUkAt9HFCDwBNp2G5GAwHcRBYVACSFKDVbmG1SrFuG4Qv/hkzSqOwg+hHQRp+kiyUWOfuwzvHH+Ol7dYe32DvbtTQzFZvCXP8z0f/sx5xsmw4JIdyzCstpir9TmTqWF53sIfgD+fjSxK8s8dDrH0q0iTatFT6DRa3sYTYsPnOhkdbNFVoFjv/oh0kdH8a022E325pfREzGOPXYWu2iT6O6go+WiKCkyx8cxN/L0Hu4lMFVmVq+TDZokO6MkenpZnF6mqUksz+6QK9poioW3YFETBLYsi+FUhMFeBUHx8GsVLv54h4ZcY+5uhXDNpLq9SyoR4dVX77JyY54Dxwe5fOEOjQaYvowrBHz80w9y8pEuDh4eoLe3k6AZkL9wi/uHexg5PcrN26ucMh3sDgPrzgbhoTSpTpmkIWNXPYbH4liujWaaqDGFnXyT6ht30XMGVUmhbjWIGCLzhRaDfWHytTxjh3qRbJ9622E4k2KtUGVqMkNpxeTAiWHae3sgeKRdlbz7/pzSL398Ck0NUH2XcvcAup6itVtAUwW0kIRtu4jsmxHx8TwXVZMJPIlACaEINivLJsXtKqkOna7xI3jNDVxbJKSLiNE4gbNF92Mf4fKbt/DqDld3TJTr6xiKTd8vPsKN//oSN8Nh+nyP7liElXKRQtthzxGRAn8/KDUI8PwAV5bp7lIpLDbw8OlLReittcnaOo/c18HqZoux8Ryjn3yAwLKQRAHsJqVSFUWROPbYWbRkN6GQhLbWIBzLkjk+TmuhSvfRLG67wt23ztMTl+ia6CeU6mBxepkdAdYWdukUJFS3gbdg4aY9Vko2w6kIigrxhIBYtbnw4hYNuUa5FBDs1qgVi/jWHq+9ssTGzduMTg1z+cId6qaL7Sl0dog88ZGjTD3Sw+hAD/3D3QTNgGChyeHuBCMnB7k9t8Ep08HNdtC4uUh4KE1Hl0jSUKnWXQ6O7JuxtjZRIioeEvY7K0gphbbqs9dsEjFE3FQn3Z0qO+0SkxN9SLZPs+7Sn0myVqiS7I3T3mozdWyQ2l4BBI+UJ/Mbv/czFqXNy3/zJTmawUgN4xQWWF3O41g2UuAjajJq2EeJ6sQNBSNmoMdDBAIoIQlFFNEMjXrFp9n0KWzV6R1KMnjmWVqblwgZUUIxFdGWCWpb3Kl5ZA6OoVkWcqNC/LEp4rEUlbUiJ06PMPzQIL2Pn6BHjxEplOkIVJqORVMK0HUdz/PQkNhca5Grt9msuVzfbZI7NcLVtTpXZvcYQGFQVeh6/BRtQUBo1lFDMSrzTcSFOitvXqX75CCVtRXckk/s7DiBXUH1HUh2sfjN88y8No85s83GzBYXbi1TFwUU38BXNTTDpKc7zE4QsGPJTB5JMJ83yVddYlse3obF0WcHuXhxh5opsFwyWdoqsbRlMdEFzXWTi9t1WrZHQvVpOT6yInPt3SWOjnTjiAbrf3+RjtFeElEFr7+f5l4NeXqVw7/zCQY7c8RjKomciO2boIvEcjqJTBgDD8mQ6R/uRU+niR/uh5ZIZXmXbCJMx8hBoq1d1vMe0oJNYW6DjKRy+LGjiKbN8paFstNk8qnDdGQMgnqJzq4UohOw3jDvmfmtZ08gRpIYqWHcaouNmbs0q1VUSUTUZGJpEXSVuKEQhALCiSiu598z47kBbUvCthV2Nir09McRtADJaxIyooQjUXzTIyqHuZUvkjk4Ro8aQGGP+GNT1Of38B2Rh5+eoPto974Z1SBcqZO2TBouNGQfVVEJfB8NicJOi56my3zL5/ZendzUANe3Wrx7d4cBFO7/8AlCPV2IsofftlBDMa7/+C6JHZeVN6+SPdBBaXWJeNFBPzdBYFcQmiXEbB+3/+DvKSw1qMxssfnmHOdnV6mLAoEPkh4lJLv7L3UQEJMgM5xiPm/SF5NxFx3MusXUMwNcvLjDXs1lYc9kYTXP5kaV8S6NzQ2Tq1sNWrbHuCSx57q02wGFvSYD6TjtksPWK9foGO0FowG9Q5j1JvKNNQ7/zifoiKh0pAwSOREvaBPoEpmeFImkioFHvC9FZy5LS1SRR7MolkK+WCSjGXSMHIT8HFtFAXGtRunODhlJ5cgHTxG0myxvWaRqLSY+chglGUdq7tHZlcKvmPzqz/ql1BBOfEnxfbanv8H21iYzN0oEso8QBKgqiCqokogng910kZMKXssnEFyUsEiAgqq5VEpt3EBm8eY2g90RBMlFVUTUSBZRVFD1OMcffJrv//nzpFsmkZFeErpOdeEmkY4YquCjDg7hraxiOCF+eGOWbd/H1QUUH+q2RyBJIMFDbkDy4TD9aZFMScQLtRgeCLG+bbPl26wqIm+9cZ0rF24xd3mR/KszHHlqCuPBYXo6Ykidaeob25gLdXr7ByGpUrq0TSgDuYleSmsl3nEFSp6DF1F45mMDTH34NMW78zz68AE279RZafiosQqdepKyZdHbJXOr1qQqayhbLWp1Gzvko7gOviiR8FwiyRCoFkfTBrmOEEO5BKWdBk1JRPcDOro18psbdI0aWIkk7qbN8t072PUiWhKElRZrL1xHPThIsbpN7/gEgdMmqLiIko/nWmSGshSnl4j1dyPrYSrXVmnJLdKpKDfvLmIrIfxSmdHTQxw42EkrHrC2uMv2rQqjSQE3I7F7ZZdYRuTGTInadpNcv8hi/v3hyX/5+19BCzS2p79BeXGWmzcKqLJIIOyb0XQRIQBPBl3T8EMioiPh+TZKWERSBLSQwO52HRORlZs7PPzU57HMPKoiIug6kqgT7ujgyNSH+P6fP48wmyd9ZIiErqOpLXRDw6u20Yb3zey8u83Fwh4rmrR/7xcBPjK2IIAEj0iQeCjCYFZmwDOxvDYHBqKsbLfY8m2uTi9y8e1bzF5a5uY78+RfneGhL54h/MAQPR0x/FSGxtYWmzN1hkeHIKlS+OEs4eEQxgdOsP3KDFcjIQqyiheGZz42wLmnz7E9M8t4WqWah5WGT98Dg4hlm7JlYSREbtWaOIqPsG5Tq9sEmoDg2siWw0AihWhIdGUlDoQVch0hkkZAtexgyyKFUoOuHo1aZY/sgX0zi8/PUqnsYppl9FiAsNJi5YVpQhNDFKvbDI4fwXVaKE2LIPDwXItYXzfFa7Ok+rqI5jopXl7EDxokkjFu3l0EIYRXq3LgyARjh7O04gHTM2sU71YZTQr4vUm2L62RG+jh6vQqte0mvZOdfP7XfvsfLUo/NWJp+8q/obb4XerVMiAS7YpiuyKeK+4PqyEhyQJGWEM0NLAc1HCAIht4lkdgtonIAp4rguQhigqzi4soQ08gGykCaxdXLBMEFYK17xLv13BkjXCtQs30mM5LqJOHaZlRhK0ys3/9Nheff4u6KmPJPk893MXgoEJc0vBseOgDk6Q/fhBV6CMQBSb/xaP0j2TY2pYZdiQ6IgadQwZJXUEJfI65Ekm/jdqTQg5Ull56h1A0gqanqJfbLL92lUiyH6tcYvm5JSpv73Lsl87yy7/2cwy4Ig8e66R3/EHKC7coVx3Of20GL6Ex3qOglxRCnkA6LJIOSfhuiAN6m+Vmm5Lk4lkqB12VSUlhtMfAd0S2arDj+wiuj+dbSCmJUNjjwx8bom/qPsKmQf6FGs0XFqn4EoEhY7Z8xEQHnmGijUToGu5hMDZFdXGLWNRAiMmoyQiJcARRSQAGl6/exsSiubLDz/3zn2dxpUznwS6UHY8z5ybRwiJzqzvotsaJQ93UVZu+h8aYPHWEYsjl5o0lInKI7iM9LO7+w/bu6ku/fs+MrO2bMT3pnhnBf9+M5bTBchBV7plxGvtmkFUUb9/M7taV9820PVyxjNvYvGcmN5m4Z+byoo06eRjBT94zc6OQp67K2IHHZ57pZnBQoeEK98wkPzKOKvQRjkdJPzhB/0iGxU31nhk35JHUFWqBd89MPBm5Z8aWW2h6imWvec/M+kqV5eeWENZqnP7fPsUv/9rPofnte2Z25u5Srjqs36rfM5N/fu59M2EV3w2RtZV7ZmquxEFX5fhAkv7uAN8RsVrBPTNuVEFKSZwYT/KFzx2nb+o+OpT0PTNOOk5gyEi+c89MSJHvmQlSMWJRg9VK854ZJZQCDF6/PE9rrU5zZYfTn3j8npkBNcaZc5OI8fI9M0fvH7pnJhMXKIZc1lYX7pm5Mb3108rOTx8J+LNPJYP0RB9hTWfx4jy7UZWlWw06ZBE9YhFP6oTCAboiE06oSIqGHLgIokrIALfVQgkkbkybmI5LW1SRJZdnv/AMRG382gpxw8AhgesVKRkP8f/8m7+jFG8w0tJw1uvUXBMrrnCnIWMLHqIfIIguRiDRkQjzyIcOMreyRaUIXfEWEd9B1BTmN21WV5s8fe4YNhVyJ0dpiyLu+i4bP5xD75BRcxkWLq2S6YvRXq5x5kvPcvU/fpM9W+O23uZRU2fytx4nlIly88t/y2XbxUlotAseoaiOrIuork3J9lHbAc2Qj+ypINgogsyYGdDbJzHni6yZPmalhSJKeKoCpk1PTiYbjbK71ODgySy5Q0n0QGD5pUU8Yz9Ox/Aj/GRpm2wkwtHDHfQM5ECVEOPd7BXLbKwvkxBUbq/t0TMQR1zPExYVjJ4RdNViE4VcUcE4nubbf/n3DPZ18sAjx6gXKog9GbR6jdlvvMvAU+P4zRJBdpCbz73J8Y+eYebGLTK5KNGOHDulbQoXdzj42YcQRZ3X/vpF5KiB2ra4XXu/MP2/v9KD0ZUirOmsXF9kS5ZZvFknrUjoEWs/MjrkoSsykbiOqCqIno0k64QMkNoCvtfm2nULW5YwHY/AsvncP/sERG2k+gZGSKXtGgRCnZLxEN/8y/PM7qwy0tKQCib5Rp1gNMeN5Rq24CEpLjgBigDHRwc4cDTHxbdvIylJuuItAq9FXDcoeT7law2OnDmMmjAJj/TRFkX8rS3Wnl+kFbh0TvaxcGmVWFon2Glz5kvP8hZoN4YAABr8SURBVObv/Q0tw2BObHPGe8+MrnPzvzzHeckj1VIouD6B5hCLxVFdm6LloVkgqh4mGgg2khfmoNOmt0/iqilQ8gNarRaqu2/Gdz36UgJpTSXqCKi9CZJpnVjaYPmlRYKsiNt0ERoqM1YDyVF46qkD+CigSpDppLRdJSht0mzB7bU9Rno7sbdW981EU+hpg5m9CmNCN8bxNN95/mX6QhGOpnphRMGLd+CUl9l8bpmBp8YJGREagsji89cYf3yKmRu36B/rRpYNdkrb5F8ucOiXT+GWGrz142vIUYNI0+Fqo/mzTXT/6WcygZGKs7WeZ3e1zZtmhLRZYzCukM4o6GERXQ0IhTQkNSCZCxM49n48sw+B6RLW4O1rJo4rEsgibdtGDeL8/O9+Br04ixwRsMw28e5DNLdnud0Ic/2NMrH+JMWrK1TrHnu354g+OMz5Czu4fp37Q2GSAzrmgkW5N8zm6h7xtktMj3HLtTg+lCK4tUtmKM3VfJM93Ub1dAYiGgM1j57PD6F1DuE2dlj8yrvoDwyhtDSW37rBZkynKSqIIsiyjGU36LElyrpBy3XIdEQ4csDg+nwZy3Jo+y4feuw4A5MjzN5dIpuMokgByY4crXbAt/77D7Atl3ajSSSb5uzREB2JHlpawIs/nOG4FEbOKOhRj7pZI7B11raL9GRjJPtzvPDqKh840wmizMydXU5MpcgO9eEE3ZR+9A63lnbIHFLIRAVemGlzMBbCbIs8/PEpoimdnZs7aCNdrP/4Bs5ulaOffZIX/vzbHP2lR5i9uEx3l4waClHc3GBlx6Gzq4POThExPUh5aYVLb69g+wGCpuCbHh88OkRDdLg9vU5b8hjs7uDtuzv3zPz5r3QjKyG21vMsLztctUJ0B226tYB0RiHeISP4HqGQhmr4xDoiiL4HioDsg1Wrk4yEePd6k7Yn4IsKXhAg2AY//7ufQam/i6bG8KwW4c5Jmtuz/MmLO8TdFLH+JKVXlqhIAZsXZkh/ZIzzF3YIezBm+KQmE9TWmtQNjdJiEdV1iOkxpoM6J/s7UWsOjbUaO2GFumwTCPtmTqZCaGcyCEYcUbRZ/Mq7pB8dwNoLsfzWDVaTEaxAwPWaGKE4lt2g11MoKTpV0ePBAZVYR4wfX9wiGZVp+y6/8LlzaNkO1tYKRDVQpIBIrh+n0eZb//0HuL5Aq1xB0zTOPZylI9FDqbTHG9d2GWu12QhFOTmmgyNQa1msbRdJ5sL09HVzc75MQhPIdEcpVPboy8XJDvXhOzEKL85wfX2BrtEkmajApTWZTtHDbIs89MwYiY4U29O76KOdrP/4Bt72Hoc/9wzf/4tv8aHffJK3X7rFgUM6jqVQ3Nzg3Tt1Dk/0kMqG0bM5yksrvPbOBpLrIGgKYdfh/kMjBD1x3nnhGm3JY3xkiNeuzv5sRek/fDobVIseWztN1moa7+zZnEjLZGMWw0kdWbTIpEOIEmhRiXBKRwpAkURsyyIckhEcj8vX6gSiih0E+IGAorh8+leeJtk9gFhbwxN9nMb+Q1TVMf7mBxdY/OFN1L0mc4KPL/ocPNbHlekdZFvkgOejJiUyfVEKs1Uy/RF83ePi7RpaPMxu2yESCERdnYpm7k+mu01kXWOoJ8OoEmbkySO4bQu3nqcyv0Y8FOWvX9lAlHwIwbmH+kkNjPDtr76I7CmMTnawW26ysdNAdQQmTyb5yKeeRTBb7Ny4hJztREtlyL9+Hi2ZItyZRO0ZY/vqNJFsB0rKoNmS+MZXvoOiquhRgVZd5JQYsCyI9KVUbuYbHG4JJI9H0aMGP3p9g5FDGRp1jyNTvUihFrn+CSo/WUBJpnC9PMkzkzSur7GzUyN5IMbqd69y8ItH2J73MV9dYPCfTtG2JDRNo+Q7vPLdt7GBjz5xktcu3MFrWJyeSvLSxW3kuIptenh2iwPDXUgRkbs39khEZQRFQ9Es1vMeCd+n19bp//AEq69M81ajcc/Ml5/J0qi6bO00uVlRmS05PNQLMdVjOKkTi0I4JCJKEEmpqFEFJRCQJAHbstCRkGWf6RsWbSnAdsH1AjTN59O/8jSq1iSqRHCo4bU0BE1hq2LwvcurLP7wJtZunW0ZkrZH5lQ/V6Z36HQdko5C9qFOmvObODWZ+EgEWdo3E4RVqi5EbB9TVFFVFxEfy7WRdY2D8Qx9yTC9Z9JIWgq3nsdcr6ELHn/9ygaGqtBWLZ5+8gBKvJdvf/VFfBcmDneyW6pR27VpOz6/8j89SzKdRDBb5NfnEGUNI9fF9ssvoyVTRE6cQhFg++o02clRHM/i8msz3JxeQFFVOsIChabIlGqzYYcYyMhc3rK4z3ZJHo8Sies8/9oWD54dYnG9zNEj/YQTMvFcL5WfLFBcLZI+Esc4NICzVmJnp0bqWIaVr1/k4BePsPidFYSCzcgTAzSTaTRNIxw1+OpXXyCSjNCdzLKS3yGu+Yz1RXjp4jZtMUCVZQLPZ2QgiRQRWZ6xCektBEXDarUoO5BDJNOW6f/wBPM/ucJl82dcM/mjH1Qpt110Xca3mviSh2lLqIFG23YJGxJmIBKSwfXANn0CzyNiSASI2KaPZ7oosoYZSKiih+UJuG2f2ctrHHw4geHWsKsVLE9AFiWaqzPcernEsUfSREceQ//PP2DRcrl5c5PDGZXenjDVpovtybyx3GQqcLi+WGdbkVAVhcM5gzQ2a4s1egOJ3prPbEbmkafOkAi3yG9UeOlSAf25y/R+9gRWK0xk6iCl19cY7DZYqFqorRrxUIiIX+TXf/ef096+w8z0MnMzRc44KqLmMEoCz66zeP48kuliv7RKs2zhygHZKZ/dy5uoE3N0iCGkrTpK1wP89f/5l3Qf6Ke8WaFagLDuI433sne7zMZmnbCmcE33ce60SXsVOnAI364g6y6vvlxFcAQOdxWx0yrtlSKdKRGlsERlo8H4h+/DkT02pBXCmUnG1CL6sT5ajW12SzY/+toN7JBKJBDwZZHvfvcdREXED0Qu3KpyejhF2FD5wa1NPnlskL1ihVR6nDl/m/umeggkkZvTFRS3SVZQGHv6OK+ev0rJb/wDM1/+wR5NF3RdJmg38WSfwIugBiJt20X1FMT3zHi+hG36CCoQQICIoig0a00IPARHRZV9BFHCbbeYvbzGqV/4H2gvPofbcjHbVWRRQtmGWy8vcOyRNL1jH+Xd/+vvmJWC983kYlQtl0RY4npT4mDg8M5Sk3ogoCoKj01lWSrUyc9XGPBVjJrP9ZjEh5/ZN/P6D5eYXW7xmXSS5BkZqxVGSdUo3fUY7DZYq7agZRJVVOT3zGzPvsn2So38dIszHWEadRNnZwUvJrN4/jzW0g5ySabW9Al8m+yUz96F55CmNDrEEJW390icfZi7NxbJ9OYob1bYtgQMzSc0PMbm7ApbmxaGLHBNF3HutMk5NTpwqFzYIITPq/nbiLbEZPcydlpFzVoEzTqjuk1ho8L4h+/DWi8hSSnCmUnGnxZJRruoWXW2Nkr86Gs38HUDHY/N9Sr5vIkouORbAoWqx+nhFHpY4sc3d3j8UJR23SSVHueme52H3zPz+hsNFFeiQwjumcmOJX5a2fnp3bd/++/+3ZdUWQA8RM9HQCQd1onrIAkOkZCMprC/YKlIILoYoRCe52PoOpIU4LsujRZ4AbhCgOAK2JrIxkqBQ0fDuFYdoa3QbtfQRYc/+uMFLpcbKIFNRzjC1rVVapqKbdscS6RBUKktlJHcNgMISA+EiVZ89EYbXRXpa9lMnh0gkwo4+qmnGH/6ON7r17l4a53DhzLMLm1TKDVYq/vcN9xHw60itCo4hk58K09LDdG0PG4vVFi8UyCu7BCJ5ZhbXkdrmjz2rz5J32Mn0aMimz++QnunhVC0OfyvP0NzeZMDX3gEfyhHey1P/5lJFr9+g9ihBO3tPEcO93H07BQbm2XiYTj3YI6dvTar5TqS4CKJIkHbp08RGXEkTn76JKPPPkrPwRH6NAu1JtAx1Eu4z0CcKbG8WaEjE0MdG8Qv72Du5VG2XMSxFO1Snr/86lWuLuzimXVOHh9iZ72GLwWEdZXjk72Mjmt0RHWqTZexkyP0Hhvn6EQ/jd06wx87x/b0ZbozEvFMjOJmwMJ6GUEG2Xfpub+PoFHn/vvHuHln+56ZQBRQJQAPwRMREMgZYKgikuAQD8soko8RlgAXJB/fFRAEAUPXsS0bAo9CWcTXwGP/WllXl9hYKXBgQMC28ljNBm67jS46fPm/XORyyUYJbCJtga27m+wYOrQtjiXShGMKezMVbL1NpOZinIoib/gkrH0zw4kQoxMZ+nIhpr7wNGMfPor34jUuzW1y+FCGrZpLqVKislVicniAhlvFLJvQYRDfynO3tb9VMH13j/mZPeLKDrqWY3Vrh1Ax4LH//ZfIPXQI0bbYfs9MLpdh5NefRpJ9Bj4yhT+UI+25xI8Ns/j1Gxz40CSlhSXOPPUgByYH2dgsE9MDzp3p5NZMHrtt4ws+oqqA6dGniJwYTjFxbpJDn3gCRalxqDuOOVei+8gBwn0GpdcLbJbqDB7uw8tl8Ms7tMMuyrKJOJaisrHB1/72DisbZZq1IiePD7G5VSYQoSur0JHUOH48QbFioagSYydH6HtwimOj3VC3GXhy38xwb5RoQqe4GbBeqCNIIlFFJnuii6BRJ9cR4TP/9F/8bCMBf/jv/+BLvijg+T59yTA5RcDVFKJBQCqm7IdRigGiDLIooGkqSPsRN4HoIosCrapFIi2ykw8IAgVfssEVkWWRva0Gj/ziV1i6dp5vf+M2c+tVDoxGcMUQiVWJkNTmrXKTShAgRRXmKnWEIsSHFFRB40LZRNgWEMs2dyM+guew6qqElqsEJQ/ZC2i3VvnJtRqp7hD1VsDOus3ZBzOsLldZuL1FaKNCavAoht7CJcTEmSlOncixcDOPL8ksLta5eXWNpKRxbLKb8MAAjVu3qS/Ns325wPH/+fOkBxJc/T+eQ+1TSB4eZ+YrrxKaGOLKhbscfrIfR1Zo1PewzSrZvh4mHj5Kb1+OdxY2uXO7xAeyae4bShPu6+PUucMwvcXQ4W6kLoObL77LSz+aY2goQd9IF6XyKobj0n36PtqNLdK5LLXtTW5cWeOtd3eZfKITRYzRaJrMLq4xcaqPW+/mGQ1DbEDjUIdOo22Si+lce7vIdsHnYKmOWcmz+/Yafk+aS7fnKJWrhPdMSA7TFlNcnL6LIoIiOySzMa5cXiO/UYZtk432+3NKfhAgSRKe73MkFyUuBlhARBBJxRRsz0eXBUQZVEVGVRV830FXZALRRRLBrNtUawFtzwNfQ5B8cAVkWeTIA330nv73/M1//CqXLm8zt14ll4wjhQ0SqxJCAt4p1mnaFnJMY65Sp2PNRBo1MAsSl20XeTMgalrMGPtm2BVoLZcJiQar56+ihOu8cjtPsjtGvRWgCnBsIs7dQov5axuENiokO0eJJlxcQjz4oRM8cLyTq1fWkVWdxcU6d+d2SKHR1anSMdpPdfo29Tvz7FzdN+PENGb+4DmCXI3kgQlmvvIqL5WK7C2WOPxkP61am1qrSDRioIVUJh4+SiAKzOYr7CzX+PSHHuKAITJ88iCH7x+H6S0Gjo1DLODCC1e4urzOUC5LIqTSlsoYjktMNxASLt2ZBPnVNW5cWePGtXXGPrhv5pVX72C6LY58YJxrb60xGgY1FeJIl05dEcn4Brevl7ACgUPFJmYlT/nGPE46y5VrGxQqe4T3TBbvOuh9I1ycvosmaciyhSVb3JkukN8oY240+M3/9R9PyP2pZ0qPPtgXWFtV1NE0jYt7dB4Os1Uo0+VCf2b/3zsWCohEVSKGgKQGRCMaiirh+z6S7YEf4IoiN2c8UEQQRVx/f51AoElI1rD9ENEYxNMGdqHB7/2gTC4aJfB8HM9G1xRUUaJmu/iByFFBYk5nP19N9NElDdd3iIYCMpkwN9ZtVMfEkyQigoYjmJzsS6AbCsQSJJIBpVqLN17fxSegy/bJJUTO/MYzNOc38MM25esrdD0yQbu5x/qlCsd/8ZO0NucozOcRljYpblikzh4mrO+SmnqI6//he/ScNNiq53htdoGHTsTZLjQ5c7IXJRRBbrjMvbFG/2P9hKJpSKTYLBW48Rdv8vP/9os0tgpc+rOXCHsegSEh1qsEHXGGDnTipSyq222u3tzFVkJ87re/QN3aRbAl2rtlvvPd1zElAU0MEY64VEoWobDOk794huqFaaS+FM1vzHLyX3+aIGTw5n/6Dmp/E8eVuL3r052Q6JvopqPvEJIkMH/5Kg9+5Ayv/ekPiHSHCNomlhpwfVHh9NEo07NV2i2brg6PRktkJl+/Z+apB4cobu6hjqapvVOm+5DO+nqRXlmkP6MS1UHTnH0zEQFJDoiEVVRNxvd9VA88x2VhRaJh2wSSjON5CJIAgbAfWOl7ROMxbM8hnjbYW2/xRy8XyUWjSIKIabXQNQ1VFKjZLpImcMiSWZcbmEEISQRRFhA9gWgoIKqHma3Y6H5A2/WIKwoONif7o+iGQjuk05nVuHJ9j42NOj4BRyQFSXM48xvPULs2jZCLENN7sdUS7eYe1SsmI7/wFIXrL2AWQ7C6zfatPJ0fPUNY3yVz5CGu/KfvMfKL4yy9ZfPa7AKPTCRZr9c5c7KXet0ja4RZeH2J3seH983EkmxW9mj+t5cZ+Pmn0DoUrnzzBbQiBIZESvQoyxLJI1liXotKw+PSXInAl/ncb38Bx6xhuTZrf3eBC4U9TGn/CzUZlamULAIUPv2bj9C8dJegK0LzG7MM//7TJOQE3/iDr3DsqQmKd1a5suIx3CXTN9FNdvAw4LM7+zqTZ57gtT/9AamhCFa1gaUGvDPb4JET/Vy+VSZwXLo6PFb2Anbr/3j37aeeKYVEE30ohmCahCai1PImquPTFiRatoUsaYgCSGKA2Q4Iiyq27RIIIoomIQQS+DaGICMFAU4gIgQBASo+Ll2RKGLKwKmZRLNxNC8gntAIiy5xy8UA9ti/WdATXL745CBKd5bmXoO7fz+PKrnU2wEdss+OI/Oxj45z7coWcquJKItIgoIj1cAR2A0cPvnkWZoVG8srI+y0+Ze//1Fq5W1e/+MbFByB83/4t9iWj5aKoVdNnOI0rxTaTKESWBb18wuMffIJrl76OqOTo2xv3iF8uJtYJIaiQ7Clc3frBuOZLFdeWyWejfP155cZTrU5GkthmFUSg2dw/RA33nyHu1eKtFyXF778HLPVKiOdBvZ2m2IOHk6kGfzV09z9yV12Vi3MmQYjXXGUtM5LX/kaYT3ggSdO4TZ8AJRA4NS5Ho5NHKKwcIfbazZBqYWBQLSzh+EvnyK/0uTWq9/jwOOn0LtF5FAU45U3eGm6wO3NJU4fLKAHMjYWuxtFmnWXOytVHp48wtLaLra7ypu32jx+uocrV3aINEU6e/R/UJSIGMTfM5MY1ijlLQRfoR34tGwLVZII6QqSGCCKMoErEAgithOgaBKe4yAoAkpURNgV8EQRP/AR3zOjywJqOooieIS0KJoXkIy9byYiS+QDCVdw8QKfLz45iNo3TmN3nbm/v0ag2DRMgR7fZ08I8bGPjnPp4hJyq4mgKIQFE0cSCXz1nhlBFSlubzPU3OKT75m59n9fIi+GOP+Hf0tK7qCsrVGpXWZyIMkrhTYfcCUCy6IjPoGfFZh9d5X0oUGs98wULy6g6JD/kxnuhpqMZ7Jcu1oklBD4+vPLPP5gF8WVVXoPRkgM9uH6IV568QLFmRp9psid7/yEYtPn0bEkm1tFijnojMd58J88yNVv3yF2tIvVr93lSC4FWXjpK18jm9OYPH0Mab0E+r6ZZ58ZoaN/38xzP9kgKLXwA5NM5zjDXz7F63/8ImKvyZlfOkcoHqJz7BjOD17k8nyd25tLPP0RndrSNuljQ/fMlLcDDvSNs7S2i6GYvHmrwNn7Orlzo0CkKXK8P/LTys5P/3370z/5sy9lEhHiakB1o0LDtJBlA88NSCkBmhwgiwJySERCRFEEZElFkUUER8b1XPSIBK7PTiXAdjy8ALzAQ/Rl0nGVWFpDF0EIAhIRGS0Z4f9r3+592rjjOI6/78lPGNuYZwymfoJAFcBAAgOFNEor1CFKhmao1Llbx/4X/Se6tUPVASlD1VRVIlVpURIpAQG9EkOBxvYFzpx9Nj7fXQeGbh06RAy/19/w0Vv6Dt/vHxusrueJnJqErTbZTBLjrc+mbnL0qsr8Uo65+UFKeo1rTZe5YorR5TH0Up2ZlVlGx2Nsb70mnIijdlw+vp3Bv5Ao629IDURxmi2C0R5ks4X5ssrM+nVyuBTuFlFLBnZPkGPZoeTIyDJkGx4Nr8lAoZ92w+Po8XNKlSqZhSHc0Ai/fv0d48NRFj67R3G9SGq5wNzqEhNSh5UHt7ixtsirb54SuRmjZUPMrjI9dxvl+QFL92doNg6YkBTK9RY3PxpjZj6Hf3yKPzWF1g7SP5JgLJsivVag8tOfpApJynsmNCyOft5Hc31MSaZ0WKGiV0ingsSjKnHF4dtHJSaTXRxsHCI5f1A1bEZzvWjhDq9/+Z1D4xzb6eCh0t2n8tuOReOtBHaNaq2F6av0JNps6wbdaBTHuzCtJkHZxzUsglGVPePf882x2uTSA5ebqdicN5rIgQB0IKn5hAMSinS5GTxQFIlAUEWRLjcjqxKBsIznS5yeu3RcD1QN13OQPZWRpEa0NwS2gyJDIqqi4rHxzGJ1PU/o7yrhRoepQITyhcKmbjIYajM0Osj0xCDbu6fMOrC4OkxqYRy9VKc/P8b09WGOKwY1yyca0Fi4liWs+ZT1NwyGNdqtNqF4jEDTw3xZRQ1HuJHpoXC3iKO0qbttjpwgJ56LLEO049FxWmi2yclWhXP9L9yIytBkAjc0Qv3ZLokuifQXn7L2ySKp5QLFD4rkcVh5cIsBKcDewx26JlXOaz4xu0qmMEX39imJDweI9YUptC7Yj0dYXOxlZj6H64M0/B5nPzwlVMiTyY8wdGca48cdUoUkuy/O0OwaL84a9LVkTElmSzco62XSqSDZbJyE7PBkt0lKlTjYOGRowqVarvN+cRaA/UdPMJtBrKaFh8rUaIiHm2WMvRM6VoNqrcWx1aIn6bCtG6SRmEhHsWs2QRVcw0LpUvj8y6/+3/kmCILwrv3nm4kgCMK7JqIkCMKVIqIkCMKVIqIkCMKVIqIkCMKVIqIkCMKV8g9L+UFhTCRuIQAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<Figure size 360x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "img = PILImage.create(files[0])\n",
+    "s = SiameseImage(img, img, True)\n",
+    "s.show();"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can also try with a second image that's not from the same class:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAASUAAAB6CAYAAAD5yEXhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOy8eZhdRb3u/6mqtfbc85B0ks6ckBlImIR4GERQRIigDEcQHFEQwQHnAVQ4oqLicQAFRbkqIiAzKFOYBTIREkKGDpnT89x7WGtV1e+PWnt3g8o9z7nPPYfzu/19ns7urL327lprVb31ft/vWyWstYzHeIzHeLxZQv53N2A8xmM8xmNsjIPSeIzHeLypYhyUxmM8xuNNFeOgNB7jMR5vqhgHpfEYj/F4U8U4KI3HeIzHmyrGQWk8/o9DCPG/hBCX/3e3Yzz+/xHjoDQerwkhxA4hREEIMTzmZ9J/d7vG4/+d8P67GzAeb8p4t7X24f/uRozH/5sxzpTG438bQggphLhNCNEuhOgXQqwUQsz/J+c2CyHuj8/rFUI8Mea9KUKIPwshuoQQrwohLvqvu4rx+J8S46A0Hv/RuBeYA0wENgA3/5PzLgO2A03xuV8DEEKo+DteACYDbwcuE0K87f9us8fjf1qMg9J4/KO4M2Y6/UKIO621xlp7k7V2yFpbBC4Hlgkhsv/gsyEwCZhqrQ2stY/Hx48Aqq21V8XHtwE3Amf9V1zQePzPiXFQGo9/FCustbXxzwohhBJCfFcIsV0IMQhsi89r/Aef/Q6wE3hECNEmhLgsPj4NmDoG7PqBz+PY1HiMRyXGhe7x+I/EB4CTgONwgNMAdAHi9SdaaweBTwOfFkIsBh4TQjwP7Aa2Wmv/oRY1HuNRjnGmNB7/kagCSkAPkAGu/GcnCiHeLYSYJYQQwACg459ngUAI8VkhRCpmX4uFEMv+C9o/Hv+DYhyUxuM/Er8G9sU/G4Fn3uDcA4BHgWHgaeBaa+1T1toIx7YOA3YA3cD1QPX/vWaPx//EEOObvI3HeIzHmynGmdJ4jMd4vKliHJTGYzzG400V46A0HuMxHm+qGAel8RiP8XhTxTgojcd4jMebKt7QPJkVaau9IinlI6RBKQFIRAIogTZQsgpEhELhiQiJQAlJJCVCWBImIpIeY6t8whqQAqxPZDXSgkKAFWgZIY1EKoWVBjAkbAItDdpGKKvQwoKxYCXaGpwlBpQE95ZASI1BgLFIKYlCg5LuPakADAIfi0YIQTIR47NQlXYqpbBWEAmNZwWhjkglPXToPpNIJRBItNZY4f62+wqJl0zhpzOkMzmEEDQ1T3DtsFBTW4uVAmEEWoTYSKMjSxgUSWXSiMgQWUNxJI8SHolUEunH91AIrLWEUQmMQEoQRpAfHiFTXYOVEQA6NJTCIroYYK0gk8lgpMAXklIUIowFJZFSgjbkgxAPQT4o4BmJ9ARRoDGeR5AfYWiwl0gLVDKFTCTJ79yGjQr4UrG1e7hyzx5dsx0hBMYYFKLybACsFEgL1lqkFLjLEZW+IcTo+e5Y+bjEGINEYAVYa9BCoaMAE4a0bW2jsamGXVu2cOixxzNcyLO/bTtNU6ZQ7B9GJDxEdYZG4bHh1a3k80UOWXoIOizS2zfCYO8Akye3sH7to9zzh/s47rT3k0Wyed9LHLH8aNpWr2HS1PkkGgSlQpF7f3crBy9dyDmXXMYtv/w1Tz38BNZashOauOWW6znhqBO49FtXMrGhnuHCCM2TGnn5b09TN2EOw4P9HHzoEfTs3cWZK06mtWUCp577Afq37mHCojk888ijTJ0xj6p6qMtNxfctm9c/z29u/gtLFkxj+fLlfPArn+Kh2+7hO1+5kvMu/iiP3vkHfvj7W/nBp7/IU2ueJJlMcNoHP0Emk2Lj04/R3T7Ae973Pp5at4pkQtGxu48vXnMV37zgk1z65a9w5Ve+zpwjlvKRCy5g0ysb6N3fTevkGcw/bAFDg0X+ct+93HbdD5k0sYUzz/sA1914Pf/63tO596Y/otGcfdUPaC5K+oMCxd69vPDEs1zxq1/w9DPPMKm2nk0vvsiiYw5nYjLH1d/6CW897jA+9dH3/p3xthxvyJRsKsL3fAJjKUWWfAmKoaEwZMmHmpKJiHSRSFtKJqAUCUIrGIksYaSRVqKVD8YiLEirkMLDWIXVgDEo7UBDCEGkNMJIrLJEUYQ1AiEUkdAoA9Y4QBIWrABpHDiIuKMbLFYqZzM2AmvcdWtrMEpgkVhp0JHFILBoHM4KhLFY3PdGMgYkIdHSuPZZ8FXCga6v8DyvMngkCmHBQ2ClxRpNGJYwYYQUlkQiCdYBjTSaYhhQGBnCeB5SC0oahKfIZDIo4aGxgEQBRlmCoMhIYRirPNKpFFIroiDEtwLPKpSQBFGJUqGAL1N4JonU7j1P+oz07aenez+RhdAatDGgHZgLKYkiQ2GwF4PEhgZEhE14WA8SxiLdIYJ8kTDQZP0kJswjjEW/rmtZa7HWvgZgyoDjgKkMRK/93GvBqHIUGANayoHT1q3b8LDkh4bI1VSz8PBDMSrL5IXzeO7JlUyd2MqMWXOpr6mlYUoLAwP91DTX88jDD7Ltb+v5869+y1MPPUpNIsfElmZmzW2lWBphzgFLeM8553L0Sccw3NfJIUuPRkkYISQ/EtC9ex/dGzuZNHkmwmvi2su/wswFi/nqd77F6R/+AMcc/lbuu+9xzjn/XK77ty/x8oa13Pmbn3D5h77EXXetxkQRh5/4L5yy/AhK0vLrO+9iuNjNHb+5meyEJHMWz+Wir19FkoCVdz/JECWmzWvlqFPey+pdT3D1H37JkrceyfNrNhMVCyw8sJXOnds56JB/Yag0QG7WVNK+jy9gz45tdO3ex1BREugif3niYfxCyNrn13LgEcv4+gXnM3HKNHb1v4qfsvTub2OgZxMnnvBO/BqfYd3LH2/8DZ9676mUevaQpZovXH0l69as5bRzz+f5Z1bz8u5dXPyDH5Ms5Zlz5Hy8TIqBfsE3/3ATTzzyOBMnTmLjpu0c8bajuez8C1jx1lMYGdpFPkq9Eey8sU8pmfBseWYzAgcSCqQRmDHnSQVaa6SUMbuwaK3xhMTzPCIbIYwlm0yisGhhMaHruFqC56Y/TMw2DKOdWliw0qCEY0UyXtlgNCAMWOnOt67TWm2QnkIK6xiHsAgc+wkxeFZgZTwgUSR81+mVBISPEBYtwcfDCjDGYEONTEs8A0KO4rgUAiOozP7auEETBEWklNQ1N1JTXUeiuopcdR02CsmPDBLu2U4iYRnxaqieMIVMdQ2eUkilSCXSlMIiQX6E/v5+ooE+UoP7AUNJ+IjqRjINk9FKkEqn8bwERof0t71C1NtBUNNE9aSp5LK1aFOilC9gd28mHBpmJNIESZ+GAw5CRxFBfoRMuprBwX7o3k//UD91MxcRIZAmpKhLFLq6CLXFS2VIDPcRYihJH1EoklSCCNjRl6/ck0dWt1XYj4yZ0SjoiBhwLULIynuvB6bXdlA3UYDrY8OFPOl0moyfZNO2LcyaNQs/lSAsBuQLJba8+DINtTUseMsS/nLLHSw9+q00V9fTtncXDQ31tHd0UlvdRF+pg6OWH8aTf3oSL2dZfOjhPHbvg+wbGKKppo6ps2dzz913Mm9CK4oCR558HE/+dTUDhS7uuO1W5kybRl19mqb6Kdx92x186WtX8cLqp5g5fT5D9GJlmj/deAO/v/8Jtr/yMgcuX8Dq1WuY3jKVrdt2Ul2Vo6tzH1+96GJWnH4WTzz6Jz7wwfNZu2Yv+4fa6W8f4sAjDuSSz13A6W87g6tvuoGL3308n/jKNci0YHLLNDKpEgcsOZyLz/8wn/nSZby6qY0brv8G3Xt7mFg7kctv+l98+1Mfpq66iQ9+8YusfOgBHvv9bfzk9vvYtHUTt/zgWs797Af46+/u5XPX/Ii+/d388EvfQuYMe3ZtxvfTDAz0MX/eQXT072GkkGdg525+t3ojGx9/gmNXHMtFJ3wEmcngJwOWHjWXFx9+iREdcduqe1n14IvcdfufKUadfOjSz1EcCNj2ylbuuf0unlj5x3/KlN4YlPyENWgEVFiHkBZrFOUeJewoOAjpgCUpHMMpz5jaCoTVGKmo9RURATZy52Mc+GhGv88ox1zcTO5epVXx31EYG7qOqgXWGCwC6xqCFMalNEJR0ha/nCLEnVp4ILQF5aEkSAlSevieS+2U8jEmohiEWG2IQoP0PKpyPkIohLBIIZBWMlQqIYQg43kM5QPCIADpANITkprmOqqbmqiprqO6tpYwMgy2radRagKr8UMYikKYuZiq2iY69u8lCosM9/dR6u0ml8uQDSNCISjpKE7bYERA7cRJdO/cSwlNy5RpKBPQu28fBiiFEbnaOtINdYx0dFAsFrGRY4zCAlIQaJeSGixGgY8DVB2Dg7ECJS2ekGhwnNo41udhSGhDMikI9GtB6dE12yvMRhEzn3ii8oSsTHDlkGNBPgb3ch+oMCRjK5OdtZZSqYjSluoJjRQGR9jXvo8DFi/ihut/zluOOpKGbJbAhDRMbOXZB59kw5YttLRkGOkvseSII0inIFtVQzE/zBWf/jQnve89HLH8HezctQVRSvDCww/woS99Gi/p8euf3khjZgRa5nPI0mNYee+dzFowhfq62TQ3+2zZvJN8YYCtLz7L4088y3vOPoeNT63i+lt/zUfP+RBfuPxKLvrAqZx88hm8/+JLWLt6DTJK8INvfoEj334Ck5rqOfDIQ9m5r5NvfvIj3PncBq763IUcecRRLDz4YP5y12NcecOVPPDQC/z1luv5670rece7T+SiL1/B+qcep2g1d/7iDxxx/Nu4+083Mal1ElvWreej3/ouWx5fyfo1T9NbHCJT1YgNDcuPOYnlb3sXs2fV0jU4wu+v/QkdHR0cuHguJ577EV5+7gUaW+v5zhcu4z0f+Ti3XvtTAjnCF374Sza8sJ0Vp72d+tokq17aQpQvUuztZOGRx/KNj53Gpd/+Kb3tu/jsJ89n5ZZdXHPxpXz4m1+mtWkRv/jGVbz1g/8CfVXUtk7gXUun/udAyVeehdEZrAxQAlUBori3VsBDGAueckATRaANnufEnjQ+KuMRlaJ4BhQQsyJrLVa7NMuzojI7CgvCwzEkK0FEGO3SvZKJYpYkCK0hoTywhqSSYCWlMMDEbZcWPE9VZl6LRiifpHLXp5SgGFlsZN3g1BoA66QrUqkUqQT4UiKUJAgN/YP5eKDEbY21lPL9yuQyTJk6le7eHkqlAFMKSdgIX1pCaxFG4AtLSSnwfKLhkRj4BJ6E0IISEt9AqJxWZI3AKoUINMJTjplFIb6XRBpLJDQC9x2RDfGQaDOa3paZnVGOhRpjEEoSGYM0Dtgr/wqJxSCRlHtJwvfxpcJqTW1a0VcK6RosVvrMw6u2vgZorAWhBGVqPTZNK7PhMmMq90UjqBwfqzdBzFytRXgK32i6hoZpqsqhhUJ5sGnVejo7dyCqJtA0uZUXnr6PZUsOZXvbLqK+EVZ87GyKoaR7/8v87emNnHXGOaxbvYannrkLLzuZ/J49LF+xnAwNzD5wPg/cchd7Nq5iMNL4k2YwtbqOYhHmz2vg6ZfWYIcsCxcfxFBfO/s7+znimPksXbqca79xBevWvsxZH76EY1ccj9IRnz//g3zyyiuZ1tBEIlNLR083D97/R/p29HPCGSfy469/ib5iiAoE53/iQtp27mLm/Lk05aaxo2MDI/15lsyazle/cRmzJh5Iwc/TsW0nP7vvLvZs3U6mKsMvfnQFfT39ZLNV7Nm+jVyultaJk2nft5ui8Bgc2MtdT69m/cu7WLPycU444Xi+etlnec+p/8rq5x+hdsp0+nZsJfIhKI5wyVd/Qv9AN3+96xYuv+67lPpHuO/Wu5gyewkP3fkgLz+7kp/d9QumzpjB9759M/ffdjPf/PefY4NO9m3poz/soTaZYfWTz3Dux85j954dPHzvc9x197//U1BSl19++T8FpW9/61uXS+WERSEMCpB4YDUI4bqqECAMxgqsNVgBSguMNngIPE8ijCUpBVYKElqjEQhhQAmQMlZQRMx44sFinZaDcIIwwiJjlhZYTagj0DbGRuG+0xqshdBYgijCSByTioFIG0MJEw9k0DZACR+lFCnPZ7gYMhSWCEKIrCDSmsAIMB5BWGSkCL609BVCBoZCbGQwBiIh0FYTGUuERRqJAYJSSHdPF2G+AEHoBDyrMUaDsWghiIyCKERqTSREfB9kZWBaDBEgrAdWYDDYCIxyaa5LqQUmMu5vo8BGaGEQRgLCaWa4Xy1glcBqUxnwFouJHyXlCSdOtSQCE7Mbg8QzIVU+CCsY1pooiiiGo8n8Bz92iQO1CvgYsAKFY2XWWqR1apGMAdBYCzFIxc2sFA1eH0I44VtZgfE89xkvidURu1/ZTsvM2TQ0tzBxWobJjQ3U1rUyY8Zk+rqKHHHCYiZNbKbt+TWsW7eZQw5eRrFk0EnIRAHnfOJcHn3oKZYsPZKe/m6CkYhFhy5hyTHHUd9YzY4XVjMYlDjo8HlMn72EA5bMp2Pbyyw65Bhu/On3uOhzX6MvLzjm7Yfwh5tuoWPPLoJExAuPv8BbDjmMO26+gccfuYvIr6K9fSd+BrLVVdx87ZUkPcWCZW/nX885i1XPPs7JZ3+COQct4jufu5QTzzyZnNU8+dCTPPHkes7/zId4+vGH6N+/lxUf/SC3/+znnP3RT1JXXcUdv7+Zod4BaifOwhQLJDIpbNLjoku+wKpnH+WDn/wiN//7L8hU1XHCaafRPLOV31z7PeYsPYyXnriHHfvasMpjSsNE3nXup5g0pZmO3iLKdPPDL/2ARMZj8aKDmDdvBgcfdwRdezt48bm/sXDhgcybO5sPXHgea1ftobW1inQmRX1tFZnqDIlkkjkHHUjjxCksPWoZc1qbrvhnuPOGTMnzPFupbMVVrrH6khICKB/XbpaP/+9ZARIkEnApjxAxK0JCrDcYa9HWElnjWIAweEqh4o6tyrtjxCKnMZbQaKwRGOuGoRUKYyN8KZAoQlzlx5gII2RF1AXQIh4QLnMEIOUpUqkkAyMFJ97iBo6VoyxLCIV2iQyeFUTCVmb4MvsY/T2+B0qCkEjh9C5l4nTFOv3NWh1rZNLpV1agsDH7MyBVhaM4QJNEceVRC0tFZVYu5dHWAVGZZY5tV/kxa3fT4+uTDjRcgl5heSY+V465ZwAyLgZkEx5Z5ZQ6DewYGGVKj6ze5p6bBR2nzVg7+hwpA5aN+5LrBzIGzzKDsmNAqpy2uRQuBkwBKmZSgY7ISp+iBzte2s6MedMo5Xt5+ZVXmblgDh3beshmPCbPbKS/b4RcrWTn/mEmNjZQ3VTLU/fey513/JmpE+ewaNmhnHTm2/lf1/6S95x3Pp3tuyHhke8aYFJLKwMDIzS0ZGnb8Cp/ffhOausn09+7lxXv/QC3/PZmJkyq54AlR9K25kn62ztYesy7+PwlZ3HwjIM4+aPn09bWxgO3/I4/PfQgf77zdk46+xxu+MGNrH/qAd79/kupq8/x02s+z29uuxdNDXu2bGbqgql8/OyT2b1jL2ec/hE++2/f5o7f3siffvtLjllxBp172pnQ2sILf32GYqkDmTDU1UylZc4cXnzyYZKNdWR0mrpFM1l7z/N8+4ffY9+2rUR+jpt+9x2yhQSZulr27NvCrClTufBbPyBbncNXgiQ+SsLu3V3s2vQyDa2TEGGCO++4m/edfiI//vblXHv3X9i7cwdTpjQi8MhkqklkPM469p2ceMo7OP7M96A0COmRSvpEUcSJhx/wn0vfckllPaGQUqJ1VNEbLOWNdKzTfspfIZ1wLSyjgrKRKEmlU0oFPSXtAEp6WOOARWgdl4ndDJ1UkoRSCOs6aAGNMcR6kQBt4kGkMEi0jZAopKJS5rZWY62ogI+0oMsiunGVsvLxsbpWua3WOoAiHmSV1Ee8FtTKn7HWYoXC8SSDktLpKNJpNuXQEoSwKC0qJX5wgn45NS5bG6Qopy8WK6QDHfRolcrKykQgrcRKjcVDEFX+oo31vTJTEUI4LU+GYGVl0NtY8/k7wdm6qiU6fr4GIiy+p0gpQ/tgWDn1kdXbsOK11/v6FGzs72NT37IFYOxx1x4gthdU7tWY9M9K6O3txWApFEtsXLuOE975Dro7Omme3ERtroqVjzxDIutRKJSQGEQA+f5Bsi1JZKaK/du6WXbwbHbt7qc3yFPvKTZv3s+2tS+h0oOs/dsTnHLGmbSt2cqc5cfTnBrCr29k/uyDWb36edo79jB7wVIWz1/A/Q/djg6G6Hm5nQFruerH/8Ytt/6eZUuW8cSjq2hoTvKz71/NrOktfPX7v6RuQgPnn3IyK957FomqCcyYOYUrLzmfZ3f38tEV7+Nj3/wizel6nnnmCb576Vf4zLXfR/qGX11zNe869RSCTI4Hf/4jTv34Jzlg0dH87OsXkC8ZdBTSPHky6IDOjh5+v3IdXzz3NC67+jsYO0Rz81yeeXIV3//aRWRTKZTn866z388733EK7R3dTJg8iZpcmmKgscUSvWGB3j37CUuS679/FVdc/V36h4bZsXc3tY1ZpjVPg3SCpuZGXnrxJfpe3c/iYw6kfU9A64wG8kMhuZzPyMgIpx594P8BKFmBlApDuTOY+INlcdl1GHClfWNGxVSBq5qVxV8lnK+mr6gB+Zryr1Gjo7ysTUlJRdSxwmCEjNmTxRgq7MzELANjEdLNqEI4zUZrHbOsCGsUSsRVPhMLrjYeZULgIdA4IHPAZOImSby4EueYzujANdaiXENj3015kFn8uL1SOlXGk44RCOHSUWNjzUyISgURHKj6QGAtEouRMfOwlHlURRBGKjAaT0qK5es3EolBW3e/y4O4DExSSiLjYW1YaRNl7QmNqQCKS09t/P9y9dLgNlcy1mloURRVnuPKMdW3sSDiQGUUoCp9RcgKyI9W7UYZXBmUxnqa3Kt5DVAJAaFxnrfIGpLJFDu2bWHS5FZ279tH7479VDVlmH3AQtZv3UwmTHL37X9h+swWTjn3RLo27+eeh1cye2ELxf3dTJy6gLYtL2EKlt7BvZz4vjO49Vc3EUbQuW0zJ5xyOt1deyjZflY9+QKZ6mp+9LtbePi+58iX2rn0ks9w320PoKN+duzfxbx589i3Yyf9/QMcfugRTDnsUOozinNOOIZsVTXnf+arPHLPH3n8gb9y0/0Pc94py4kKlut+9yDpZsmH3v0BvnXtF/H8GTxz5wOsWv8UF3/1S1z/zW+ybdNGjj7+JGYvX44odHHbzb8nlUwikllyVRl0Ic/3f30Lpx13DL/94x385f57WPqWo3jo/oc48eQTufrLl9E/0M3ChQt5/8WXMKG6lWQmSduuNqa3TkVLQ2BDPvW+s5g9dzJf+OH19Lf3Mri7nbqZLdTokL88so5jjz6Y+gmTsAmB0YL2rk6qs9Xs27mbZx9/mhNOOZqhkRKtra0ce+h/kilVpZwloFyOLwPG2NlKCYmxkfMfYSmbBXwkGouJO70nlRvowjAYmr+f8aQbBNa4gTzKQuI0xzozZjkco3IA4ipEFm1wrAGF8gRKKcKwhEJhTIQYY4wsp50gEdLpHmUV3MSpQTwswZbb91qtowxMMq5AOv3FARQIlHIVRj8+z5OQkDI2TlrHfqwg1MZ9fwz0juc4sJMxCNj4vlrAalsBMl9IAqPxEBhh3d83FiUca1PCVsDAWkuEE7V9qRF4ziumFJExBHHF05UuYs3KxjqXFQRO0UJb0No6hmshiEaZ0srVbRWh+/Weo3I7/jFouXOkfK0QbsyoXiVew+Rs5ZoceJlKn4miCKUUw8OD2AiGh/MUB/vQSlEaGSabbqaxMUV1YxWb1m1icLiPrr6Ak04+lmuvvJaDlk3n/Z/4JD//7i8pjvQybWoLA8O9fPgzl/HM009SlZtMZCPa1v2NVQ/eTk9XJyrhM2nSdN564ruomzGdrEqQL5XYvHYtfb2d7NvZxuaXXkQCiYRPJpWmFBTQkasKT5w2DW/yJC795Bf52Q++wfJjT+I7//Y19rTt45of/ZxHn3+MY084mVy2moQv+fm3ruGs95/G6nUv8swDDzKkDfMOWcpVV1/LpMlNnLR8GdrAtNmL6G3fTjpdx/s++FGqq2tJpdO8uG4VyVwjt173Y4Q3Qs/wMEcf9zaOOvpkGnK1DI4MctAhy/BUlh9+46ukGqr44Mc/ye5dO/G0ZuYBs/jND67nXeccz4++exuz5kzk0GUHMXvhQjzPp7+/n6qqHISwZ/8eurbvJFmTYtaig0GEvP3Qef85UKrNJq1HiDGgjMRqQcpKar2AZCJNQyqiKp0ilzakkh5RKUSisL5PfxBRLBg6B4cZjBIMRZaSFCjPYygK4oHsQEAQi52vb5wYfc+ldAqtDVbYeKDYmDU4ILHWupQnBj9PgIp1ikonj9kGNq78iNiIicVaiRBuMJb9UC6tMXhWVVI/JWzFIlFOtYgZm9IWKwVe/L0J6epXngTfU/hlthADYmQNaIsRY9JEXBFBSqfrSM8NTisU2gCRjtOWMdYJG4OItmhp0cbGhYYYiI3TjCJASMf6ykDsCUloBZGNkFYSYWO3uMQSYvEAE09MEqNdGhwYVzyIolHgeHzN9pjpvD4NdKCktf6HfqS/N1yKMe+VWdPY17HVTsesNBaFpKgD2nfvo3vPPhpaJrK/Yz81qob23i0cdcw7aNu3iaF9AZ+6+P08+tRz/PzbP+Oy717GC3/byrTpE6lpqGL/nt307x/AZlO8+MxTLFt+KG858hiu+fLn2bdpFZERhKEGadA2rkALVzWeOesADjjwYKRUYA2PPPQAfe17iaIIYwx11TUMDvaTSWVJpnyU9Al1xFAhT1pq0qksR684m6t/+G2OPOxYPvv1q7nisgu46sY/0rZ+AwcfspBsrp6Orm6UUGzZuIlMTvHliy7hml/+AuWl+OR5Z1JVnUULyHo+3/zJDTTU1eGrBIVikZ17dtMyaTKfPecMigLSBkraWXmqcjVMnT6DA48+klt/dg3HnfEhjj1mIdd+9yaWH72Y+rpF5BpzdO1vp3jSMioAACAASURBVKmmhoVLFtI+sJdDDjqSrdu3kEvn4ucp2bD+JRYvWcSGtWs5YMl8XmnbzdKl8zhs1pR/CkpvuMzk4iNyTJqaYHJrDelsikw2BdEg6ZrJiCAgmfCJTAmhAjCWUqFIMp1CCp8SEf0DnST8qeQDn/7eQbZtGuLptcM8vsfGs+morqOsrFRh4uwvdli7md6PZ0npOYNkuQOIWGeS1mKUAG1xfdYSMSqUSynQxiKVQAgPq20870tXWdQKHX+PiAeVY3YCY9wQ8VXZe4WrPpZ1HtdQhDBulUrsllDCQ4gIXyrnHHfYhRdrPNo4FhUJQSKudllr8WN2JGUMDDpyYGANNgbxMhAhhHOKx+lN2bAoBRWNzIGgu6kyvmcivrYyCHi469USUloSKuJqpsQKl5oqG1dHhQBrSEh3/cPRWDYzJgV/nWA9Fmhef34ZyMosq3yNxlqsVfE1uGf79+7v+G9YV/20QUQ6l2HeogUkEh6bX1lHf34nmdoJXP+LH9NY1URDXYZNOzqBNF/83hXcfefdnHLq6ezZ/Sp33PRHDjvmX1i96imq6psxKmTG9Nn84JJz6enqp3dwCC+VIgpDtDWEYYhSiqGhIXK5HBs3rGNgeAiEoqqqhigIKYYhQbFEVS7LSLGAn0qD59HR248QgupMlmwyRRAE5IOQx277PQunzqAxlUTrEudfdAkM9fK1iz7BtFnTuf62e2hr281f772Nj33sUu79w6/52s+u5UsXX8zdKx+gsaGW4WKRqmwGYwzz58+nfX8Pa9e+QMvkSWRlgnWrVoOvEIUin//JDUxrbeAbF3+OT33jCr71mUtpDeZx+HHLWbHiFB65/zHO+fAnKA3tpXluFY/duYoJDRlsYz17u/Yye+Ycbv/dLcxdeBBSFvG0JSwFTJrSSj6fp2XmTHwvzYLp09m2eReHzZryT3HnDUHp7SdNIgpL1E+oxgQaKQxGpfB0AZnw0VERT+axJkkQ5lFEhFEBz/MRWpBKpNHSxzN5PAUTmgyHLfRYucdibeQYipBx2mIqg0zGFRmnNTgWJLSj51JIt6YtHmdKiFiAdymXpyShdGVzaSEwIb7vk0slmJSzGKsY0iH9w5IwKmIwCDwMBt8KrHLaDVDRqIyyKJRLi6TE2hApVSXVFMqV+MsASWz882JgIrZK+MKLBWvnSHe6CnjWVcWUtUjlBqcvYjuEtK591rqVelYgPM8V2IVBaIEUCk2EJ1zySmzXsOV02jrRxosriJGEND5hXCU0xmAlaCS+BRIKZVxqrGPw03GapCOIRISHdGmx1K/pMw4n3H1zzDO+F0qhY01urK5UBi0l5Wvc8sYYR+msSyQdq/VjgLSVtE5KhYl0XL20VNVl2dPTSdA/yIQDDsDThuaGyWzoXMvcidO48MLPMjQ0QirrE0WGVDbNYF87+3dsIpGDptYWpkxuRZs8J7ztJKonTuSGKy7hD1dvY8vWHQzmC3ieh9CWQqlIKYhIJBKMFItoBCP5IqVIY719ZLNVGGMYGOhjKD+CDS2GYZJ+Aq0tdfUZ+kYKpL0EQTBAVVWWsBQwdfJEisVhUpFl48a1XHLeaXzus19h6sy5rNm2mXXrtjChpZo7b7yWljmzuP2Om1g4fzb0F7l95YOc+87TqU5XO/Y12E1d0ySOWjKP7/3kRsKRArnGZk456XBOOPmdWCCd9JnY3MRvrvs97V2dDA9arv7V9dSm69i9bw893V3MmlHP44/cw3vOPJ15sxawf3EfqVya6dPmkk1H9O7vYvrsGdS1SO67fSVnn3c6L67fRF9XNzXZJDPmL+DVXa9SW9dIXV3dG8HOG6dvj/xbq5VKkc3WoDwPaQ0IDyUlyk8TBRoddCPw8dKSKBREGgwFUrkqSoEhDAuE+Yj+oqV3dz8dHSHfeWAEIQ3O+TRWY5AOJMqiZlmDsFRK9GWfS7ls7/w8Y4RRyrK78ysJITBRxPnvPZDhvfvAGNKpLI1NPouOO42f3nAnm9ZvRyqDFAkHjCr2/8S/QyxQW7cur9w+UV4YHIOjiV9F2WMlnS1ACAdQKOf0tloihCYsV5jQblmLtbEHzDEDKayrYnqjFTKASNvRxanaoIwkkKNl9ygW0D3ckhn3OYOxCiNcCiZj5NWS1zqttamAiwGQYvS4sQRmVPMCpzX25Ec1pafWbXc6VJnxjEnV/lFfK6ftcsx5IhbBKywrZs9j0/Cxr2WAKq+pS2bSrP7b87z1+H9h5UNPsODAuWA1KZXm1Z3bSSeqyNVk6OjYz+MPPMg5H/k411z1JQ5c/jaaaxuZP38+ba9s4J6bbyApBN193YhkmmKxSFDIUywUsMDgyDBRFFWetbUaT/pkq6qZPXceQRAxMjhA2/atWGvJ5TIU8wWCIMBaS0J5pJJJ0pkMg4ODIAxK+mQyGawOmNjYgAkDEpksGza3IUTI1OpmEtNmc+a/fphTTn83z61/kYfuvJvPfvWzXHL+JwiLls9d8WU+duZ78HM+VkMmnWMo388Djz3PsrmzeGjVOjZseJlfXfczunr3IgoB7zzxHfzrhy/ES6X52zMv4YWDLDnyKCwBWmu27WijuamJx/+yklNPP43QaJSwPPrwY8yft4AJLZNIJAWJpObPf3qKk04/hq72AXo2baZ18UJyjbUMDo6QkpJIWk5+y8J/mr69oXmy7bGrL0/6aTARyhpKYYSXUAgR4nkpDCWk7+MphQkLGO3elzKJ56fQRqNDi5Q+paBEcShgZETz9OYC1sPN4IzSfWNjDcWKSv1HxBUWaWINRUocGXCDUsWDUwiJkU70toB2CRBRaJgzbSJD/f3MaM5QX5tjeqNAFwrYvg7e/ZGLqatNsumlnfjKInyFryRKCfyEwBMK6Ul8Vf7dkvJ8pLKkPIWvIOElSSQUvge+BC/hITxB0hMkFUglUQKs8FHWID0QIkEKS0IIEtL5KITCidsxmEkpkL5CCDdQlVL4Ml4DqKSjuUogpWMmSIHn4dJISQySEiUVHhITszQhZEXXl7EVwkRxmUKUK4JUBH8be80soHA7CEjrvssTguFglC2lVYo5y5agbFkutwgl0JGJq6XuuDajqWUZkEz5dzsqYo91yI8FpdGpB8dc4nRRSkEYBLRMakEYmNI6mVc2bGTbqhfp7u5i+szZSF9iCXju2Q1EJcOrmzfS357nYxd8iO7efqqaqvnOJReSyvjsfHUfe7u7GRgcoVAs4ifT9A8Nki8WqamtpRQECCnRYUhNdS2+VIBg8UFLaZ4wge7ODnq7u4msjfUIS1UmS0IIWpqbKBb6KRZC+ksRDdUZqjIe7R2dVNfU0NHdQyqZoDgyTH1TE/u6ehnSIVF/Dx+97BsYW2ByXRN/vuUPzFtyIEcefzzHnXwCl370AtIpiAJLGIVkskmUSHLfPQ/wiz/dSUJ5TJ82ndt/8wt8qTjjnAtYftw7IOnT1dHBjFlTqW+dRH6wl3w+Yu/OXVRnslTV1jNz3lxa6qp4+MFHydXVghVsfXkDOV8yYeY08iOGAxZO4YE/PsCUCXVMWbgA5XvoMHL2aOkm+zmtzVf8M9x5w/TNiAyREUShJpGBZCpNcXCYTCZHyRZQSlVcxol0LVZppEgRhHlCBamEj1aCcDjChhEqofBTBuV7sUt4tHrlkihXY7Jy1LFSMTH6AmUsNjLOz1QulkmBiGd5L+64WIMnZbyFikamUrROTDMYSKY1CExmEvmRDvZu2EMmfR2LWxfz52SeRLIG33dr34R2psEkEEqJ0BGeBB37ejAiLq8nQLh1aQnho23kBp5xA1VIZ55UUiKNQUgVO9UNlUr6GC2lzAhMnPKYWFvzlMQaZ1ZMJhJoHTmrgHCObiXcAmODRVnt9CTtUiBjBcKzJPEwxhDqAOUprJIQg5vynIHVGIFRFqnLuyaYuFigENoQCaBcERMGbRNAUOkzWx74MxfcfStaZCARoXSSqVOn8MMbf8vAwAAWg1IJjM3jSYsg4b4qrvqN+q9GmaGx8Y4R0sYlAGcFcRKkxTp/CEJYxyKFYNPLLzNz5nTa2tqYN28eBy1egvUkOozwE4KwYJnV2sBQazMv/u0JZEpz1y03s+H5J1i/YSvTpk2mr3eIggkpRiFJ6RMVRkimfGdv8X3y+TxCCNLJFDKdojZXRT6fJ4wMpVKJZDLJAQsXYQRs37aFrK+IIosOSmTTKbo7u0hV11EaHGRGSxMYy659+5gyZRqRjaipqSNEIIQk39eLUD4jpQAdGj70zkOYfuACZi08iLM/cRGXfeRCrvvdLRSDIj1d+8nm0pWiQiEf4icTdOzaQlN1Nb++7mdYJSmWSvh+goVLD+Tyr3ye8y78NMoU8BI+06bOpA+LJyX9nYKJk6cgE4ogX6J3qMjRxx/L8PAwgQ455cwzKBQKdOztIJ1OY63g+FPfwUBvPzaKnMCJW6CtiA3AbxBvuHWJlIApIZVheHiEaGSYdDrpdgqQEukptycPEQYNRhCYIlpIpLSUCj1AEc+3eL5zHCulKmV1FQvRMl7HL6WMj7lXz7q9may1yHiQS09WRF4hZcX3U14r5daxeZVlK9lElj179jAhZ5g9t4FX95Xo3tHJtEMOZua8qezo8wj7t/OJD62goT5FZEKUNSA1qBBLiLIRSui4Hc7/JGXMnrD4cQXLCuOE5Lg6JJVDTmHBaIuQsUwSV9+kp1CeREhFZE3MIizE1gHiQeoJB0gi3lKlXHESSuLj9p5yq4stnnJsUllVWXTse/G9VQLP8/BUwi3/8RQiTi9FvLeSUu65GCXwpMCXHp6SeEqihFuT50lnt1BGViwg5dg0UqCgFcP5AWaFkhmmyNYdWzj56KO58ANn8fH3nMQLf3sMYQ2BULGQrdE2qrxqY1x/EmbUKCpMhSmN/QFXAYR4iZNSJBIJFi9eSCqVYtmyZdTW1mIEREFIUMyjEhl6+zqZPGU6/Z1dLJg+jcLIAL4M2bx1F6EJ8aXzuA0ND1OdzRGEJSY216OEpL6mGt8YrDZgNMPDgzTW1VNdXc2E5hZapkymvr6e+ro66uvrWbrsUA457AishlQyQSrhExiDSibIF0qk0lkQioKBusYmCkGJQikgQlAII6T0SCRSKOWqr4GxlIykQXns2TbE9JlzqKrNMBIV2bBmFY31NXR1dZLNZkkmk6TTDqCyuTRD+QLL33YiHfv3ud0l+vtJpnNccdXVvPDMI2zasJ5cJs2aVav56/1/Ydu2bYTCo7unh1K+hPFGU+tkMsnSAw8iKBTxhCSTybi9xeIlBXV1tW5SMaaSYpt4AnmjeEOmFAQRiWScKydSRKUA4SmyiQRaxSuXbICfzYKxFMNhhMyQzCUoDAwgZAIZWopBntJgAS/pkx8ponWEVAnXqWJfirBjCXlM0WOWoKyAeKuLuNCFGLtswQqUtSDjhaWUdxawlOwI1VVV7O8GrQZpzpQomSqCth6MSjO1OcmGNduYMS9i0ax6Vq/b68rpFsDHSg1xOd4TYKQzNIbaCdS+J9BWOZ0NgTGCKN5EQXgK3+K8KDJAp3xyURItjAMsUzZcGgLrgLa8t5SQkkR8vcIb3XXBGIOPJNTOsa19D0+6+wMuHRMorIxIoipLZSoMDItQcbqjnWCP9NDaooicgVJG+Ih4+XUc2tkJpAAMKCzSE3+/Rs3zkGjSqQRbTRA/H4vySgwNFvCiiD9//zvcpofYUUrj+ZpwpMAXr7iKRYccjhYg0a8RxF/raTJxJzGv9UNJRRiGeFIRhg7IPC+B1pq9u3ZTV1dHFEUEYZGaYkgulUGnLSI0pBqamL/sUFIZH01IfWMD1bkcPT191FRXU1tbTa5QYPfedpLJpPNBWUN1dTWJZDXLDjuUpYcso2vvXoL8MJFRTJsxmSgIsckakiZB04QJzJ2/gLYtm9m4+gWCMKS8sLgQlAjjSdcZfx37irTFaIPxYzuKdFvsCCHIhyXWrn2RsHo/3/36l8k0VFNVU82kaQcwNDREda7KpYAdHQwNDeEnFKl0ms9ddCGnnXMGL697HqFgxbkf5tVXNlFbW8+C+Ut45unH6e0ZYkrrZF5c/QJ79+7GasnuHQXa29uZPHky7fs7Of7dJ+Mrn57OTqZPn15ZwD7We1ZOvaWSlEolSqUS2VQaK9+QC/1vhO6rpllTMihCkukE0sugS8Mkq3xSmSReOgM2iQkl1hbQRuIpCymfga5uUqk0+UKJIAgYHC7RvivPsy8FPLhRoyWVJQ5Cjpbv4yWn7n9jmmaFQKDjWrutbOxWEXyNILAGTwgCYVFCEBiNEoozzjqJofWPMnFCLY0ScotmsOPZLTTOn41fU8dA9z727MxTawZJHHAMTzz4ABhLZCI3BoTbiUAoUUF5E3uEJNKxnZgdKeF8ScZALldFlE4yvVnylrceTlXLDDp3D3LXH26FKARjCYVA6lhkNhGBsfgCkB5KxPdFxOmtFYTWYrSjxJ4VBMatFRQCIqFIGk1QTq8kyDGG0VF2Ec92wiClh4lChHVibWQ0obZuqxlkvPOAdNXPSGO0xkqBiTRIibCWHUOj6VvrlBmOxb2ubF/eaXLME3Xpl4CglOfI2im8MNTJhJosV97wJ5LJJIEO8KWPNuEYhijivbsM2ASpZBIbryXs6uqhubmZffv20NLSgjGOZShh6ezYR3NTC8l0ik0bN9DXO8Tigxaxr72TwqDBiAF2rH+OG264gaAUsXBmK9mGZja+/EpFbFdKUCqVKvt9rTjlVLRxaxnzhQIApdDpedlslp7ODno79zOlvoFlhx1KIZkijAy7X93F/ff9uTKA3TIu7dirEDTUT6Cvrw+pnF7mmQjf9yiFITvaOwFISJcdHDpnGl7jJNaufZVCcZBsleS88y7gxpuuJ+VlSGcyjOSHqKurw1rLKWd+hD/+6sek02mM8jl1xZkUdMDcmXPYuO0VTjjunVx/3U9ISMVRxx5N375eOguDdO7ZxTHHnsjjTzzCeR/+CF0d3UyZPt0tLo+zFaUUxWKRdDodZz2jfc7G9pYwDCkWS7z3+EP+c0L3+vuvuTzhS4JAo4SH7xlEIonVkkQ6g1IJrAnwEkmMtBTyeSB0zmY0URhRGi5QKGm6uwybtmuee1XQE2goO4WVRViFFIaKgEJ5zVcsyAoTp0FlD4sThp3m7WGsweCqSAiBbz2ENAiV5oAZdTz+0BqOmNdCUPJJNWbxCglqF8znoCNPoy6doCFnGBkuUSrk2b1/Px0dPTRMaEWX8iigLpWlpEOsr0hrZyWUwpBUHhDhSRl7kSRalhBBgKitZc4kj0OWTGW4q4t0uo6etqeZNHc2UxYexI51r2AURNrgC+kEfmWxeCiB056Uh2cNUihnEkVjhHC7cFonP0tP4Nl4EW4stJm4I8iYPQnpSvoiZpjWiXEIQCsH9NoaV1SIq3gCidUaq5yrHECIKPY3WUbXr0D/GKG7tqa+kk4L4Ur2FfZX+VEOLJRESh+ZTNFTKrEolWPnQMTGDc/x3rPfT3EkQAtdmQisEQwNDzI0NERjfQNGW7q7u6mqytDV0U5DYyPSWurqqlFCoa0kikKMNRTyATte3UZPd5drP4ZsropcpprHHn2I09+3gvrWWdzxm1vQJqKhoQ7f88hV1xGGARYIgpBsNkd9YxNvOfwtvLxpC7t2vsquXbtob29nz5499HR1sG/PTvbu3klPTzfSKiKpeGXrVgY6tlPKDzBl+kJmzp7FSy+uJ5NOoaMI35MkkmlSqTTDI0PxvXMFEmMcKzaRYaQUIIXAGgfEs1sns23LK0xbPJ+ujt00tczmbe96N14wQtuOHYRhQBRF5HIZrLaccupprHzkAYSA2XMOIJutZqC3h1deeYW+rk4SyQQNNTWohGKgr5cNWzbRv6+d2XMXsPbF55k2bTqZVIo1a9fS39fPzBkz6e3uoaauxlVsjam48vn/OHvzIMvOs8zz921nufvNPbP2kkpSValkSbYky6ts48ZgY2NsbHDbdEMTdg9MsAwdE9MMdAt3Az1AQPdAG2aGGLPMQDNesA0GbFm2ZcmWSosllVSqfcuqrNwzb97trN/55o9zM0tiAsWEb0RF3sq6WVWZ59z3e9/nfZZtnHD0XFFOB57WHNr7TwPdr1qUzn7jPz8odI4UJXCqtYcxBboaUNhSDZclGVnWx+WSSs0wHOZ0t3r01ob04oKVXs5aB9Y24dJCwguLGc6W6/RiVGCcsAincNIiR+492xuZEY0Q4SRClkJex7bM4sasKkbiVSELclnQbLR5949/mI2Nq/zke/exuhrRmsnobg4Zb47xw//63/Hw3/8Zd95/J/PX12mGYLMOkHP4ljnuuOcu4hRsNGCYxNQaDbyiGDGj8xLHKXs3EGLH5ygsBLffOcexPU3mZiZZu96lVs15/Q/8BBdOHMeIjMnZm7iwlbJ17SqekggpyEWpE/SdplCldg1XlFiRUqiixJpUAUJLPDniEAmFkmIbAIRRx6lG20gBO7SFbSpD+XeURU3lJZtcyhLfUU6Wm0t3Q5tnKbETgS01jaL0ftjuwjaTG9q3VmvsH9EByuL0cra2UnLnc1IqfOMhjWZDFIigwjGt+O0//nNumqsSx5JCCGq1KrZIqQQBzUadLMsQwuH7Bq0162trbHV7dDsb7Nq9m8Gwz4WLZzDGcPr0aZr1GlJrPD+gVm0RVnwqtSarS0vEaczG2iq//Ru/SXfjOkJrfN8j8CRC+URRjBeGOGup1WpkSc71hWusr6+hlEJryVZni+GwT5omKKW4vrRIr9sjGg5IoojhYADWw8Zb1GqKiZkD3HHn3QyjAXO7d7O6ukKrVaPb7eL7AaEf0O31UFLsOHQMkhjnclJb+ogpKZlf2uSeO26jc/kSce7z4X/xU/z5//H7dDY2mJpoMxjEFM7RaDTpbG6y/5ZbOHniOeq1Kv/+N3+Hv/vS55DaQypLMsw5ceIZDh97DVnmOH3qNL3uFnv27UYUlr27dlGr1tjqRswdPEA+GOCEZGJ6Cq01Rpa4oyvcaPFSFiTP86hXa3ieRxiGGGPYO9P63orSdz77yQedDLE5aF8hpCDOywCBwSAn7m+SZAlWhKRWMIxzejF0uylJrohTj2yQY4XFZYL1tYSXliwaRy4hKDSpKEr8RlgoRh0OjIQe+Q74W+JXogR8UWU7LdSIROkodW2lA5AUJchdn2jxuruPcGBmlvZ0wHjlIC0DU298E3/4a5/kJ//1Rwm9XVxduIovBL3I0mw2QLagNcU/+9Gf4IUnHqHf73PgzqPkwy2cV8EXAf24R2OsTiuoYpMMZyxOON7wun3UpM+FjQGbC5f5wM89SDZ/gVjlHHnte/lvn/sHqo2Yt771hzh5/DGg9GwKnCDTZQkuvb4pO0NRfvdSlFoznEPL0uBEjrRnZZm2KGRpnCfKQlNu/Mobw4hS0uKJ0nalyEt7F7tNSHW23HoIhysk2yRwtovaiHGfIymsw9qCQZHjCkcvvQF2t5pjo8KjdgrSDVHtDbGtlGqEG27jCxKpSzB3Mc25f67NFx57iW889Le85/0/TGJTlCm7tiTJdqQmcRwzPz8PznHwwH4KJRGZ5fL1a7RrdeYvX+bF557jxDNP06432Or1SK3jbz77GR77xiN4uqDZCMhieP299/HwV7+ERNMbDhhvtUjSBCk1EzMzSOuYnppmc3O93LJlGd1ul2q1QhxHJenVGBYWSwdQJwQut4RBiO/7VEKNzB2L85eo1kIa45PMzs6xsrLK1PQ0q0sreMYnTSLyPMNoRZGnJV45Ip8O47xUJgiFQ2HJiHqbSBNyz12H+dIX/5b3/8RP893j32FpeZlAawrhiOOoJIr2OnQ3N+gP+pw8eZZKs4W1KUZXSIYRxvNYWl4m7w156dRJdk1O41UCFq/NU6tXkNowvWsv5Ja53XvYs2cPaRxT5Ja1pWWGccKePbsJw7A0RgxCtDaA2NmWCiHYM9383orSw3/6Ow9K5yhIiPoV0kwyjB3dvkALQ5RpHBVyERIlBVF/iHYa4dnRIZ9iwgLjGdJhTDyQnLielxgNUIii5MEIYHuEc9tcGgA1eq1EFMVI/rGtnSpwonQM2ObRSCmQQmJ0gNaOLM544G3fx7c+80eMje3GNRQvnniGt7/jQ4i24s63foBHHv5zaM4yMXGQyu6D3PfWD4LnOHTTPsbrijgZMKZT+sNVJsc8ds/WOHjTXt76g/fw/e//EAduGmdtdZU0y9nT9rnrDUdZW7rKsSO7Ofqmd/P8w3+NvfUO9u9t89Tf/Rl7bj9MfH2drqlw7eSL5IUEUTo1eUisKChcgQ+gLKYkYyEKRljbiNNDiXNIVfKOGPGSZOHKUSwvSG1OmmWkmWUQpSRZSj/NSZOCOC9IUkuWOwZJRpYUDJOMNHb00owoS0lyR1IIksyRAokTZLkgLiAV4Gw5Ig2zG51Ss1GydV++IfvHZMeXA9hyNOKJEW1im5+12I+IbY/7Zub40te+zvvf/z5WlzdYWlpmMBhw8vnn6WxssLKyQq0acunCBbQyPPXkk0S9LpfOnmVpeYlet4tNY37oPT+MCX0uz18g6Q9Is4yJsSmEUBy+/W7qYxU+9eDPc+jgbq52euRZCs7ha4UfeERxwoc+8uOsriwxOdZm6doCSRyR2BTf06XPV5aR5zmTE5MYSteJfTMzhAIalYD+oM/C6hpSeqwsLrHV2WTfTYfIbE4YVli4dh0vMHhSccttt3L16lX0qNvUUrM1iBkOU77vB9/D0tVrTM/O4VzBnplJcpshsggXNjj3wtMMhkMKoZnbMwM4arU6SkoG3T7D4QCk4PDhO1hbWeU1d9/F6bPnGG/V2VhbI5A+B47ezC2HDyMUXDhzmsnxNhPtiVGnmLC2tojUIe16lU/9/u8yMz3DW9/+AJVq7WUH0SvF+y/Hr/e+SlF6VRi8OubjNwO018SvKjDluFQNHFZlmDAkcw4bNxg4BwAAIABJREFU95FZh2qlghd4GAV1T+J5ksDUyoQF7fBNQdVsm5iVnYATYJzDyRxXyPK/JFQJHG/jte7GSaxEuQ3c/kZxcoeRvL2dyrIeeeKYHW9xx5FZ7n7bG+jHq+xqNPjYL/06l1YWuL5widWlZUT1Do7sOsTYRJvbjt1Fd2MRaYdcO3uOk09/mze9/e14QrG3qhlmdRqNOaK4w+r8OjpssLaxyZ5xye5Zj6MH21y+eJnXvPkHiXWLl775Nea7Gyx/8yHWv/ZZTp7pcvnUWVxzguvnTuEFTVSe4+eaitwWdZYbyQzInBz5F5VFWFJQWEuW5cRxzDBJ2OwOWOtusbE1YKsXs9bt0etHbEQp/b6lGxdEqSMrBENbuiwNnCOKLL0kwwqB1YZMaSyKni2Z30oHpBnESYZFkGYjE74iR9kRJuVKj/SXP16pfSv1jdsdV3m9yg5uG7Te5hmVFsQZeZ6W5nw4KsrnxPoie0XG//CvPka7ETI+MUWWZSU4r2B6YoaTJ0/ywonnWVpeQDrL/PwVPM+jyHI2VtfY2tri7MVzPPXM04RelX0H9mOUZDDcQCnLFz73V7xw/AkAVtY6iDjBKE1nq0dhM7bWVxCFJcsT/MDQ720RBpqxVpt2s4V0IwM/V3Lblhaul+Nl4eisd+h1B3Q2OgghadXqhL7GhCGeUZw7e5apiUk6nQ4Tky2cLTBac+LZ5wiMV3b+UhKlGX4Y8O53/wBve++HCP0KWTREOonxauTW0Osn3H7s7pFljcRoyfz8dZQy5WZSa5IkIgyrBDqgPTnG+vISx48/xf6DB8oAC+3x3o98iKsXr+KhEIVjZm6W3laf1c0Onc1Nrlw6z6VLl1hZuMKf/8mnOXTzYe6+9z7Wt7oUwo42yiMQH40SBmuLEobwFM88/eSrlZ1X37596qPjrjVVo1r3ychLkpgSeIFPkUYI8hGj2SALR5zmyEDja59h1CWPc5xUpHFKp5czv1Dw9AsDHr1iSyxIlsDXK4WbxahW3lBeM2KBmhF0IgqBkqOt2EjuoUYxSFJCbAWqVeE/feoPWbrwJGvPf5muuYVf+MVfZGVplb/8o9/gnR//H4mWVtm1dw+Pfuvv8P2QSxde4sDMLt7zYx9n8fpZNleWeOHxxym0JHRD1PQdrJ97ltbMHHiGerVGbeYYl777EHLzMn5YUBs/RHXXrTz0zS9wbNc013uW2rXLGFng7TvAZqFY31qiMfk6vvQn/xeBX2FoIwor0CicKMhs6YNkCzB6RHh0BYUtM+ukcyRZgdI3fm7SAYUgEUBeUKsbBgOHy3JqgSMrSuuYvrPYuKDmQ7NZgzQnN5JhN0FUNaGRZFaQJ+XKOk4LmqHBCshzS3eQM1LFYnSp5VvqRTv3zP59N79sq6Re1h0VO9u3cpNmdzCl7VAAKTVKmtEa+YYERVjFVD1kfm2Vmblp3vW+D9Pt9llevMxYu83K2jKBVzoael6FIo1Y39xAKB9jFEWWE9SreEGF+9/0FpTQXDh/CewQY3zOnz9Ld3OJlfMvsrLeZd/eXZy5tFgmp/iK8cYYQbPO/fffz8LCAnI44MyF83jC0I9ibrv5CLtMhWJli9hmvLh4hVwLmiYoxzibEWjFwcndaM+g6hVOrV9h+sgt1MMaeQGBX+WxR75GkaUkaUQUleOgkganHIGu0Byf4r/75U8yNtYiTjP6/T6/+vM/zaHZabq9LZo1w+1veB/zV85xYf4SOkpY6nRoTozhSTECoUtp0tjkLB//uf+J5bVlQLNrZpa9B/ZTr9dJkqQUGUuNLUr+mHSQ5wU2L/CrAbV6Hc+XXLk+z9biMt9+6JssrS+x79AtxMOEWr2J1YbJXTNkwx7PPvYdLp4/z/K1izQaLV48+cw/uX17VZ6S5yviYY+x8Sp1U9CNY+p+iG9jTGBRYZUiMaMgyWXqIRQanLTUag3yakJ3bRMpDRVPMzcNh9YHfONStrNx0r5CKYNm9AOj3PSVKSNlYVL6hkeQEALPSfIiQ3oKYW9EJOVGo/Kc9aEljXLWOlt0Ll9mSd3LzbVlTjz/PI8/8pdEKeydOsBzl85x8KZ30F1/iePfOs6Hfuwnyajw0Fc/T7s+QVAJOPb2H6XRnmTx4kssnfwGJjDEWQe7HpE0fMZadeYOHaO/PMPRe+7l6tlnmJtq8fO/9B9Z2Vgk/+Lf061ViHvXMOtbFFqwa/wgw0CxWSiCJEMUijSXCJdRoHHOYowiswUytxgjiW1Bo+mzuJ7QrnkEGgIBOEeUWnylqbcMm1sD6jMtIKciLYNhQW4ttaqhyHLqYZ28mmIlJFGKsw6dCRoVBb6PGya4oiRZpmlWbs48SZpmCCdKnKMQeEqW0Vm5esU9E8fxzsatKLKXAdqjrkkIsizFGA/nCorC/qMDKSlvTOEhRls743tsWMc73vl2mq0JwoqmUZmgszLP2uIyijLWSijJ3L7drK2ts685yYGD+5ifn+fQoUNUG202Njborq0zM7eLsYk6t952L1JKnjj+GHF/QLPRJskc/f6Qw/tnuXx9kV/4tw/yH3/t3/OR972fZqPC8tXLrHY2IM3ppSlH99/M2HpMNubDvmnOP/McMqxQ2Iyw2mAr6pNKDysl312+RiEK7mns4jWt3Tz5zEvM3LyfXXv3ENSq3PvGt/LcU8cxIyeMLMtwSuIQ/PBHPsr9b/shcmFZuHqVNMroRz2UkJy6eI49rXHyNODYXXdw/1vfxqf/t9+HImNQZHQ3N9i7dy+Dfpd6vcGgN6Tf76M8xfTsHNtZhsvLi1y9emmHsL++ujyKDCu1ekkSlYVN2bITdJAOMraGfU4//yxv/5EP8rk//hTWlnIvCkuubvCvrLWMtdpo7b1a2Xn1opSnEa12G0WGkBlj1QDfgB9oClGgqSHrAyRVrB0vxYlZhHIh/XiI0mUya5rmDHo50sH0bIP7b6nz9IVNfCVoVQzGaHAZSIVzauTX7EYtqC6JWdmog5KlP7cWCqUcTha4XOyEU5KDkAFa55x84VmO7Z7jytmTHLzzXg4emuXRRyu87u1v4OLpp6hWK3z1y3/JcHWe17ztHVy8tMjumw9wz5vexZVz59DSUa8rqmMz7JUFtbE5lq++QDx/lTVR4JlJpN9mrOpRoFmJE+5/x7u5dPE8m8sLvHj8UWyywvryCkK3CTqbBLe+kUER8dwLl/Ayh1EFuQVPlEW2EiiGPYsrLJ4SoHKGeYk3dTYyAl/hbEG7GtDrxjRbFVxvSNrNWLWSWt1DB4L+RkZuJbkShLUaqijwKiHDoigtZ/oJVd8jtzEZBVYHbG32qfqKwPdY6Q3JC1f+e85SD8sAwQqw1RmSWIfLQb2yJhGG4cu0aewUpe3xenszt7M1leX4VpJDLULo0WvtCGwsOTxKWp48/gS/9Ud/WqoJpOSO17/hBr7o3A6T+OWP17z+xvO9N4sdUuXsvgOjJGXHr/76f2IwTHnwX32AQObkVrG60uGuw0f5/Gc/x8/8m19ha/kyp06dYWJqhrWlNXSjTby6xm5VJw5Szl+5TKoVslrBOIfIEozRuEgQeAE2dwStGsOtHk92Fnkdkvtnb2HRlCZ5eb/D1NQU973pzXQWr/LCCy8QZSnKD3DVEM8E2HTAc88+TyFy8jznwgvPkSUDlA6QlSoVP6Q6M0sR5XzsZ/97/vpP/4TJ8R7VSp04TjHKI43LDjjpDTDSoKUgTUcjcyEJwypJkhDHMdYJbAHWlSC1UAalShM9bQKEENQbhpUTT3PT4VsZm5iiP0gYb9XYc2A/e4/cwma3x6WXzrBy8TJFlmNaNeI8/v9cp//fRanpVWl5CWS61PyIHJdrkmFCJZgkdVt4Ygp0jBDgqSp4BukZ2qFkY3WNOE6phFUqdYszjgnpODpb8OwFVY4oOHyV41zJizGm9AOXVlIUlkKWhMicAknpxy0VpYNiVOIduRTktiB3OVkq2Spy2oQMhh2C+h7ecc+9PPbkFaTcxYc+9HHOX7yAHzY5ffYUe2anWLl6leN/87eMT06zculp2o0JJnffxPy5l9DzNd727puJ6nWMp1i5LmkeOshN7bfwxBOf5/VvexfPP/Ywt92yl6i7wYWLpzG6bNtl+yBf/W//N7/4q/+Zz/z5f+H7PvozfPLB3+I9P/ajRN0rFK50VfADTc86PAlrvYxhbsuodAtJWmbZ1YLSIrfhe3S6CcMiodKokacJWhr8PXUWrm2Qodjc6pCkBQ1fIp2jF/Wo1AIqoU8gclxU0G749Ic5VgiqlSr9zgCbO4bOEmVJ6ZhZSFILyaYlp48OJHkGVWOQRYoJvB0m785BlucYY5CjcaEotsmTI0fRUWipHblDFnlp17I9zuU5O2RC6RxC5IABJzFehaX1RbpLHZIs3ZGgbG1tkaYpQgi63S5KKQaDAUI4okFMnqdEUUSlUiGKopJHV5ShpSVpUTPo9Tl87A7Ov3gCV0hyhly5fo31xHJl/iJBUGHPvt1898mnUEbj4qykXQBxmuFVa9QbIYXVKANJb0AQBrSkwqtUy0JsE1qVCi4tWC4ygjilXRljdXmZ6V27WVm+Tr1eRwVVch3QbI5z9OhRNgYdTl44RdBs4khpt9uoapX/9T/8CvV6HSEcV67Pk49NQpKBKuPN3v/PP8Z//a1fp0iTUmhdLm9HAmbHwMYoVwYDVIKAvCiIogF5XmCMwTlHv99nc3MdZy3NZo08t8xMTdPtdkmShH7XUm+Os3zlItcvnsVTBdY5Ll+8xIVzF3cOjXq7RZqmZJkrKSzfa1FK84RBzxDICJ2VwlYRCCpeG10J8M0YTnp4ypCLAttfIM9S0ixByzq11hgVcvIkJcw18TAjTXNajTImKXQK6Ry6GOXEOYGwQF76TZejicKRkeUCKQsKUnBm5AKpUUqQpw6tPPI8R0hJVVdITE5YneLF555naWMNG9e4+RNH+eynf48HfuBDNFsBH33DJ/jNX/4pzMZ1apMTtKua+Y0VApcSt8YIWzNI4XP6zAso22PY3WKy0kS2PPI0QmSGx7/xtywuXyd+9hsceu17yJMuUgl6/Wv8yHs/wNJ3PsejX/w9xufG+OLnPs3b3vn9bCx2uPzUi3i+JE8t/TSnWvUZRilSSvbvbrOyNsRXECAJtWatk+KpnG6SEVYCojgnWe8zcI5qRZGu9Qh9Qc1TZElOGOrS3jYvUMKRDVLmNyOavqbRDFnKbUnVUJqtTh+XQhhoMleODp4KcDrH1yXOtTOCmZEurXAYXZBJA9zAlDzPQwiJIy+5Ty/TPAnpADcqZGXBKgvV6IuFKKPSR4XrRoeVUr7TcxbOnMIKTWFLL3apFdUwIPQ9kIJms/Qw0lpTFBZjvLJbG/mJe55X5gsWN+xltoWrlWrIiRMniJMYV4BWPp3OdV44/jgf/Bc/TX9licO338n555+jXvURLsOfahPGGeO+wYUBg2GMCXwq1XHiYUTV1FGhz+bmJk+/8BQawT1H7kRpjdWS6+fPkxQpvpKEjSbXLpyjEJrDR45y4sUTJEmCLYZ01ge8+S3vIKz6pGnGb/7KLzM+Pr7jZqkLzXqnj9MZwhkaYZXM5vzoR36Cr/3NF9jsbqJxSGXodruMTU5w9fx5Br0+YbXCxPgYrXYbKQ3Opqytd7BJjDGK8ckJakGIzVJ6vR5FUdAfRghr0VphPUNYbzI1PY7UYQmnKMP24kZKA0iUMiglybKIV3u8KtD9Zx8ed9qz1Fs+XkVSn56hUi3b6/Fd95GZWWTrZgLtUQz79HvfgOg6aa9LToRUAYVN0ELTWeuwsbrFILWsbCp+67M9cpdTC3w8XbbpWllyFLktKQPSCRJbIIXGUVrtRnGOkgVGKmKboZ3Cq5pS75TmKM8wDDSF87nnLffwgbcd4ML5Nd7wjgc48fXPIduzPPCWH+DUie/y/PkXODx9iCi9zNZyhzPHz9FuKmZv3o32NOHYJJNT+9l7292MT+/m2kuPc/HS01Rq+3Eq5MoLjzF38x1MH7mbvRPjHP/2l9i/+04Wrl/GDyts2JgDrRn+n7/6NG/5wfdi9Bgr1xf50ue/xkvnTuFl5RsrzqDqjczOPE2RuvLk14p6wyPPoUjKCxzbEaHUFkjfkKYpytekWTnHB54rN0/Woq1A+yVAKVDkhS2xIOt2rHNTl1Lx/PJU7EX4YUBmHduhDE4U+L5Hv5egPIVQkKcW35RjdpLlXNu6cZMduvkIWZaVIzmvpAYgCop8BF6P5CI7Bm5Ss2NYIxxKm51NntYakBjlEScZv/TJf0c8iEtKyI4ZwnYii0DvuFeWh53SIyb5KO3m5eOkc2WRLIpSRjO0EeNhwO/+2r+lEoTMr3TQvs8DDzzArn176W+uc+3ceYadLmmasrC8woff/m4Ga5u8dOYlNrWlu7FJ6UNTLmdUAVXfQ/sBRcVjdmKGVj9j+thtfOPJx6j6HmOTE+Bprpy7gDcsWPYdaZ5x++238/Tzx9m3/yC9QcYdh+/g4OwU850NHv7iF+gNBpiRyN0YhRcY/uff+D2GcUZgKrTadX7/f/kNciwuSdBaE6UZnh/wwLvew+2vuYs0z1/BuNcSNtc32NzcBCAvLEmSMDU5R5rFO1vuWq3G1SuXS2eAwnL67Ck2V9a4+757mJyc5JZbDzMsBEFQKd+bUuJ5GqU93vXG79FP6cRnfv1BYwqUyZFGolWKCX2UqWH9PbixIxy8+8ep776Fzc4iyfpJ6C2R29IeQiqBFRprUxAZwqZoXaPXTTl+JmGYKaSSyEKwkeZsxDlxIqjXfaLcUjiBYaTDMgKZFihZlGRJIwgCjyx3pGmORBJ4CussTlfI0ohTz53mne94Pe3duzj++MMcOXgzsjXNxbMv4lUkqfU585Uv0vQU/+FPnmC+kbN2bYMDtZAs7zM+M021GtAcm2aYpCwvXMZkKadOn8B4kkpzmubkXpauXWZ8Ypw9B1/LWhQTJXDmzHFWLs1jnGAQLXPLnfdy7uJlnn70m7xw8izCKcZbdZotn5qU9B3U6gGdUVxRrRFSSNBOIaXB14JKxSe0GZUwpFavofOYmvHQAprSUVMGISRGO2xalC4AFGR5KYrVWtONU4QUFJ4kzlKU8bAqpcgNnl+myoShQYYe0lmMKgmBhefwAo3UCs+TYB2JAq0MW4Nk556ZmJxGaY1Weqf4OEremuRGukuJA227R47ImgKcu+GftP3121u6AkFYa1D1Bbv3HER7AZ7xUJ5BaYM2ZZdWSkwKnBWkyZBT3z1OtTXGtpgyigZ4nmFycoIwDEjTjHKhopFOEmcFt73u9dx+9708/cRjOJtz6cJ57nv9G9BeSH9rg7GpacJKlV53i83uButxl77LymQZo6mEPjLNSzqvUrRabbyKT6gU0XDAtWiTl06dYG7XLi5duUJ3ZZ1+t0snigh2T9Pr9ajXaoxPTLCxsc7q6hZHbruFrz/8D3ieT2Nsige+/728+/0/wsK1a+RpTOEgVIaXHvsW+19zN/WxFteuXmXY32JzfZ3cWpRW+FrTj7qcP3+RN73j+2m3mlSrdVqtNnGa0hsMmJicYnx8nF17DzAxPcPuPQeZnp1jbvcuZuf2MDk1Q3Oszb4Dh9i97wDTc3u467Wv5943vIV9N9/K+PgMTmh8PxiJxAEhyBEkWcqRg7v+SZ7Sq45vKMrIbecRGA+cRRQaJQOkTdDxKtamJFud0oMoSXFSoIwkFYaKUQy3NhC2wOUZGR6CHJREKUmj4miFHqktCHLBXLPO1aUO2niEziPuxhSiwPMV0pYCW6E10ldkFjrdCKE8xsZC4ixla1jQHq9RqU+wtbYBTnJxaYve5SU+8tYP8tePfIbXHbuLrY2rXLjYZe3ZM+w+sosi9Bkbq3DwXoVQr0MPfWyyQa2xh3ptktzlBFpy09G7+Op//QrpYMCaLTlWnc1V5m6+k++eOMVbv+9dLC1eJfBCds3eSj4BUbHMbbfex7OPPkIr9Hn0iQu4JCcIFb6zyL5DB4Y5X5NGGbtrfmk9G2VoX5DkOU3jGBYwiBMatZDuIEFKi1ev0NkcUAkCXEXQHSQYIVDOYDQI4yhyS1AzANgoouULRE2TJhnhZA2bWBwBGUMGUYHwPbICnC27qigtMIMYq8DTgnSYUIxM6aQFR/6KW2YnstvdEOOWH294dheu5KBLrXYCDYS4ofjf5i45Z/E8b5RO4vA0uKzH3/3NP3DojvtK1wZbkO5kAN5IPxFCgsjxvZAzC+vc/84Z0jim3W6ysrTM/JXLbG12qNTqI6yj5PEopTDG0PAabC5eAyDLMqrVKs16nbOnT7O6tkX3+mmmd80xNzvLRHuMtLDE8wvUag2SJEEoqDcbpHlOGsdEWGpeCEoRVkNmm3Wk1MhAs2kzDu7fz/jYJBtbHR5++CHSNEd7hjjJCIMWu/aMc31hmX37b6PRHqMSBKytryKl5Md+8uP4xifLMob9ARub6yzPL/DSiWf5+899jqPH7kAIge/7eJ7H+QsXmJiYxNmUrU6ffm9IvV7H83I8EzA7XSeKY7wgJMtLX3hpJIPB4BXuDWW3m43GZEOSJOXYbe2OtbFNs51Dprw2N5xCv6eiFFY8dEXjh4DSFKkijvpIvwL9kwRexOLx36ZQPna4QFCxJH4Fz8bkG12cHCcIQpLhZpn8EPfo5zWGUc56P8VpSbsGk1Mtagt9soHlwFgdioKlfkzdaeJQsNUb0ByrkiQ5mXQEaUEt0ERGUtMFFVNmnU1M1BBBFRVqMu0xtX+cE88+h95Y47ML59Bzezh1fh6sz8xkk8m33cVwdYX86gLvPDzH5Wf6fOJfHiUWBb53D7KIqE/tYnN5mcat05w/eZaFtQ4r11dppNd5/CnJ+//ZPtp3H6UZezz39CNcXz5Hq7aflh9y0837uHahR2NyhiAo+MZ3XuLYrjpXFgoi6+h1I6Zm6qxv5kgfGmM11je3MJUAWVEMOxH1eoWBS0oJg9BkRFQmq6SbPdI4YbZdoScKTDWgGYRY7agLS69bkEuPuBAoDL61RMInsBm2FyOlJBkkJLmDIsWTgsCE5GXmD54aBYoWBTkaV0DWT8l8RcXzEEVGHlmyf3TPFEVpsBfFEVJK4jjG88oVcLHNqRKi7GTc9uatTDMWqmSm50VWhi5ISZ7fANIzobAOqpUATzr6w5hAK3yjyQuBr/3SeM6WK+scST8a8OEPfoDLF07TbE2SJAlIRas9Rhj4O4UyS1KUcwRhgKPg+rWrPPz5vyLQimEEH/uXP8Wg16PT6eCUoH3TPo7edReNSp21zjpZnGCqVYadLv1h+eZdu75ENawwtneaer3O2MQ4yveohlWefOpxtISDB/czOTlJvdnmxZMnuL6whO+HaG150wNv5mOf+EWunDlPnKfMzO1HCcvq+hYV3+ObX/8Kx+65D+cEvilBe994JEnpzKE9w7ve92GkMAR+KUyKkxLYL4u/xDMFCLNTbJRSZDbFGLNzyJQeSaOOeRTJtV2UpCwQwuxco+0/20mtURJRlAeN53mvKGr/1ONVx7czf/87DyqvIAgl1hYEYYjWoD2Fkj5pFoPYgngel6yQ5QMym+LyLkaFZKSQpuS5JenFbG4WJFnGlXnHo5dTap5kstWgGKbYtKy2ypfkXkA+iPCNwuQZVc/QH1rqvkIWjmYgsLElCCUiBZcVDKKCKB4ytX8fulEFLXntPa9n12ybYWeFiYO7uf/ee/GnbkMpwdb6IkW6iZSaXGkOvfEd3H5rlW6RsWffXUztnmHuwBGECFhZPI9pt6nXWtBs8tDzy0zdO8eL315ldmaK/NpLvPWHf4yw1mDx0jWSQUzCkGdPPEO72Wbvvr0M04hw8jBnX3yeSwvraK0I2x4oTUCOcCnaU1QCn1o9wPMEtWaNNE/RSpIr0I0ayvfLEcUPkE7QzTOyOEcWBdoVRP0+qRN4ucPaHIVDFQ5hc9QIsFZS4EuJzstgg1ApjNJ4vqRZDfEqHl7gIWx5kxmlcFmOMwqZOaI0I82K0vHSFnSiG93SxPjUSNtWsra3b+6dkcw5kCWOo5TCvSJMoAyR2I6/2u6udr5W3tggnXrxOY4cO0YUJ0RJQpZZcmtxOJT2wOVoDH6lQqNR5fOf/xwzM3NcOH+GS+dO0e10ybOU5tgEzXoFISHqbtHb6rCxusr0eItnn/kud77uddz3+vvpbG2B8Th98kWyLKPf6/Pot76F8QzffuzbjLXbTE1PMblnD9VKlebkBAduu43JPbvYd/Ags3NzTM7NcvnKZZavXeXCuVOsra5QMx5Li9doNdu8dOokG5sbaKkpbMbePQd55rkTHDp8lLBSJwwDcucIQh9tDDcduhVnLUoUJHEKDobDIbYApbeLjIcf+CANWt8QxG5vSIVQaK1HBn9qRLcowyikKgXzxhiELJOAjPZK3MlIjPFKIa4xOx3mDdF1+XujDUEQoLRAK7ND53g1l4BX7ZRiAfURs1YphZMJLvMRSUTicjzRgCRDCE1RZGgyLKXHjnVDsoHFioJ+r8daJyJVkt6m4MxiRF0JtKmwuNFnmDvaoaa30cWr+wzTLlXrQObgHEGoGaQp/bygVeT00oCaKXWikU0wKPq5o9UwXLtwgcbcbu5+0xs5sHuGL/yfn+bmAyHjUzdhpM+b7jrKI1/+NiIZcHK+oMkyP/8HX+c7j3yeqmhy+52v44knniAd9um6M1xZXaWmKiw89wjj00eYnmpR0xHP/P2Qwg0Y89ZYOZPx7He+weTd72Flo8Oe/ZPYKOMtd7+BUy8cZ6PawJ+6icHVk4yFGqcEXq1BraYxvocNfOygT6c/RFpFW1vSRNAfRng1TTqIQQuyzS0SYfAKyIQtfcStRCuNLAQSSdurkKdltyKMwfNKkXPmCrJhCSwnUYqjIPcMDgVZjl8pT7Fep0ulWlIEdGBIC0hFjhcoZFpggUB7ZYHzwRYGNm4A3S/Hg0qGtfflWUzRAAAgAElEQVSKk1EIgc0yhBilkLiXGf+P+EZSlIJrxzYLvFyECAfFaGu4uNBlbnaWP/zU/86P//MPMzExwdmzZ5lo7cEKTT8eEqcJgQhY3ejyznf9EHtnpgilZXVVoRzsm53i+rmTKGU4eNNNnF1coBqEVGulH9AD3/8url+7xuLiInmeEwQ+qysr5HnO+Ow01WaThx5+mIMHDzI1s4svfPEzGGOoVxusra0wNTZOc3yCubkpmu0WZ584w9rKCusL15mcGmOlE7O8uUm73ebSlcvUGmPsPXiIzY0t9u3bx7kz5/joJ34Wz6sghKPX65XvQ8FOUS/VnxKpy/dpWK1Q2BL4l1IifDEaf/UN9wbKbmZnAyluxMVrrXEW8jwtO1dKyxg1KkbbW9H8ZeC4Uoo0jVFK49w/khC5cpRTlAVvu0t7tcerdkrf/otPPqi1JKiUtUsbHyEteVYgpAWdYAuIkgjlILEVyGOiJCdOUmwGnbWMOM2IEsPCgmSjp/nT73QIqhXaGqq1gLmxKrqmWegMcKlF4miNVdmMMqwz+HWNcZpmxVCr1RhvSnwjqWhFVUv8iqGFoEgcyvjsO3Y7QWg4dekaS4sdjt1yiMOvv5/W2BT79x/h6slv40SX+uR+dt3/bl787je5++itIEO+87XPEmJQtuDsie8yFrSYaFXZWF5AFZKcKh/+4APUQjg8VeDJgtn9M7z7l36XjSunOLDnZur1JnGes2u2xfraItW64DNffpTuEDaiIVvXN6kqSzzoQZ6TRBlSeQRO4vkKF5cbJE8qAiGp+gH1aojrOgLfo9oIaUy0kEmOLBzheBWGCb5viKQgGuYkKITLCDyP/kofoohCFMisdBCoCEmtWaXX76OqBuMbRO6wuWOQpBTS4bQirAV4qgxM0H5As2YwApI4o7CgXMHG4IbJ2+TkzM5zrdUOzvMKD3LhRonAIzvbUat/Q7RZ/hK8Mq1k52an9C9/6Ktfpdcb8NTxp3nsse8wPT3Jb//BHzB/4Rx3vfZ1rK+vEw8GtIKCi6dP8NLz3yWJIhq1GmmasLG+zsXLl6jWKiRJTKvZYKvbYWNjnc31DWrVKv1ej1tuuYXz585x9swZkiSh1W6zsrRMpRLSHB9nY22dC+fO0mq26Xa36A/6eMaw1euRRH18rUj6Xa4vLpXcLGvxPENmBUXhuPnQrdx133088fjj1OtNDh89wurKCpevXmHfrhkOHX1N2Z1sY17a4I26kCRL8DxD6Af4no/SCs+UKSlGG4zWaFU6o0pRWieXHRJ4vsF4ZZHQ5kbHhACpFEEQlJvPkZJiu6hsP5dS7ozmnufvfG77Wr+8+9ruoraZ3Qd3TXxvLgGP/cVvPeg3AgrhyNIcPIGzCU5DFjmyogBypCmt3chWKRAMekOSNGGrF5EXHsM4Y2vDEqUeX3lynY2hwGUWpSTVesig3yfQhr3tOiZ3jDUDqoWiojRNVTARVtlY3yTUms1OH7yQuBPjVT36eUq/n1OfqpLmBfXJJhvdPl7oM3/+EpWGYf9N4+zfc5ATJ56gUquzfvUM8XpGv95gUiX8yMf+DVI6vvjbP8Pmhau0Z2pcPX+Khx55ljRZZH19FZP0eeHb30EFq1T3v5sg26Ax9xqi9WtIbXnp1EX275mlMb2L9dVV0qiLs0NOnDiD7S5xftHxlS/+A2tXOnhthQkCpqaaCM9HeRKRx6UlhZaEQuLXq7g0xR+v4I8HrC70qY1XaM62SNOceK1LfaxJZlOKYYo/2UJWPDYvr2KFRUlFrVKhWtckOIo4w+IzEJAkeUlgG8QERmPGa+V56ymG/SGVWoiRbif9NgwEGh/hLCLQ6KrGKI2NMgSS9eGN7dv4xBRClriREBBF0c4N+QoQ2omdLkiI0gEBAUqa0YlL6Qoxev22z7NzI6cEWQqCpfFHgQKG3rBDiqMb93FbXe44doRBd53VpSX2HThAnmdsrK+zvr7OrbfeysLCAiYIiKOIZrPJYDBg99wcS4uLLK+ukNusTCJJEqI4AutY39ggtymVShVrM9Ikxa8EZIWl3+9z5MhRNtc3mZqdZmN9nSAM6Ha6LK+sMTE5wfLycuknhWQwHBCGAUhJFMVsrK5RCMfhI7dz8uwZbJKxsrzMvoP7mZ6co6D0xb4xZkkC38czZuS55zBaY4xGSoG1xU5ns/16rTRSlB/FKLJs29Vzu5jsYICjz21b9JbXrtShKqlwspSKUTgKW7qS4sB4Zmd83y50L8einHMcmPsei9LX/+K/PChFQSEsQlUoXEaS+zgRkOR5ydYNA4ZRwmAwpL8FhayRu4IolURDQTIwdDdTLlzOOHkp5dgezdPXM2yRl2SqNKVaDUmjhCTNqDU0SeQYPzTDtcUVGmNNXADB1ASd9T61RoipCQKvxEz8mqQ+1UQkGcor2Ipy9h09ysLVa/zsz/wcP/rmI0zPHeXwTQe4fv0yNnXkW5cwe+/hgXe9j4N7buPP/viTnHzoIXJVYDzBoy8s87mvXCORNZ453+fa4oA777+FYnWFhYUh45Wc1775+zh/6lnqoSaJUmyWMnfgEMrUuH71AoH2SHPFleeepN8ZspiHdFa6hDqnoiQVBL2tiCKOqbSqZEJgXI60BUNpyTJHNEgJgxCrPLL1AeNjVa6cX2J8vIlMLWiDc5agVifLMwqb0xqrU5OaykwdLQRxLwFbUG3UQDsaoY9HQb3uQxAQtGq4QYoaZPhBQKAlntEUOZA5fAnCmDKEwBjiOKGIJFlqMRWD1oaVrcHOPTM5ObOdxg4OgiDcKTwvx4deufaXSFkWIqnKMANcaWmihERphdYeSskRfmGQQo2EuwbjhaAKKkEVLy/4hU98nLizydUrl8ooKBzzV69y5eIlkiThzW99CyvLy+zZt5d6rUZrbIzVlRW63W4JNaytkaUZd915FwsL15i/coV6e4y1tTVaY03G22OEtRqFhUG/T7PZxCYZJvTZ2NwkTVMWV1ZI04zBcMDM7Bzdfpf+YECcJNRqFXrDAbnNUdpjcXGRldU1Ll+bJxeSjU6X3toas5NT1JstQi05euwuilFatBylg5Q+RaXT4/b20JhSmAxyB5ze7rBezsvyPK+k7iiNYJSQk9tROKzDFSVXMBpGNxYU2wVu5MpRylOKUWdVdlh5lpfXTmz7xZemb7awIyeIcmS/affk91aU/vjXf+1BI8GogCTLcHlpvpZnMExTTFglFxWErlHIEGVaRPmAbr9LGgnSvmN1aYuLV3q0G4KjeyXHT8fMb1mU0sQ5VKsGvxoitI/MEuIiRQcGu9mjXVPU21XSYcL4XAvfOAqlaY43yZIentKoouTf0KqTFoa5Q0c4feo0jUqD49/8Wx66dI0ff++HeeyJv8YvBpx+4et4hU8iE4QfMjW3m7anWHvpEcYO3MbE/kN8+svP4zUDDh0+im5UWe93Ga4OqfnrBMawvnCRqUM3MXvTMR7/8pdotxtQNWwME6pBjd4wIsuGDDZPcv7FBcYnmvz1PzyDBqzNGJ8KiCKLlAG2SGCQ4Ic1mpPjBDVDNojKE7gakKcZIrPM3jrNoJdQrxs2+0NcoQirGoEijQcka128WkCtUWMQxRihELljpdvFCoUfSJb/X9LeO8iy677z+5xzbnz59XsdpyfnAAwySQAMIkUxSlxKtMKuXLK0a2q12rLXW7aq7HKV6Kp1qJW93pJdtstcS3JQSassUeSKIgkCBECKIIDBDCZg8vT0dE4v33yO/7jvve7B1kJV3Fc1hUF3z+vuG773F75hpcPU6dmcpW27bK5uUfB9pBJ4U3VarTZWoYju9elpqE4VKExOYAYDbFsxSOM8eVdJtE4pFXySJHsIlBqNGaQlx3FJeaRTmj9ZzV7zt2G7lqPSuBUY2fgKNQQiy8ay87zfXKCrxm0AykIgsDwPbQyO6/D8s09y99Yt5g8fwS8WuHn7FtVKhcbEBNudFs+8/wMYKXE9nyxN2djY4JWXXiKJY/bN76NYKtHaaXH85AkuX7mM0bC6vMTC/UWmpqeZmZ3mzTcu0G23ctB1bXa2t8h0StDvUfALPPfcc6yur5GRGxEOBn12WjuEcUqcpnR6fZJMk2qoTTQolMr8+Oc+z4svvsTnP/+TrNy7T7lcIowiJhoNOr0e3/7G13nsmffnAmV7NDAWYxKq4zj55ixJhgsG56FNWA4oOahZlp23zPBQlbTr1pBXVUaA47rYyiJO4mGFlFdTqc7G76+EzA2UlRz/ETL/MzKos4fcNT3cuv7QoPRnv/U/fumt233iQNDdHuRoikEJG20VGAw0nfU2cSYIOxHtjR47y5us3OuTJTapCdg3ozh9sgq6z41lw/W1jI1uviVxHEGlZDM538CxMqozTXrCJU4i3EoJz7dwpM3E0Tn6G6uUG1VsmTLY2CbNDKmW9KKYOFRsbXcwVkZvOwQ730Y8//QhXn/5Ml/4wn/Ad/7y/6YiNJVKHa88zzPPPk3WAhC8/f2vceXi27QerDF78Ajffu0+3Z0Bnzxp893X7pAJm1a3w2f/zicpTZY4/uxnwZpjZ+UtXn/tLWw7YerAPhzLoTl/mkxK1m5ewCQpl+902Nzp02nFCKHxLZtKqYgrHaSKKTdc/IJLe6NH3OrRbnXRbpHG/hlUMqAfRFieRWe5RaVSpjhRI8FgCYMsO2RRhkgME7OTSKmIWj2U6+D6NlmWp+yWKsV8ayfF8CmYYsUJtuchqhLfCNJE45RcknCALBYoVDzibki4EyJth7jfg1buFGCSlCzRZGlKmqVsdnfbt+npfWiRe3wjc8AxZhhHrs0e+cgupylPOM49sKVysGwPy/XyNkDl3k7KcnCtXI8lbQdtctmCV/D55V/9Faampjl//jGOHT7OretXKZcLFEsltNYcP3EiN+LrDyiVy2RRwltvvkG/16MxkVdAx44dY2Z6hmAwYHnlAWsra8zOzVHwXCypeO7DH+Lqtct84hOfolItYSkHz/cJwgiEpFgokSQpvudz+9YtDhw4QBBFRHFEkml8zyNMUgrFEmmS8DM/8zN8/7XXUMqhH0TcX1zk8z/xObI0YnNznULBH4NHa3ubSq1OsVRiZmZ2OBfaE3n+rs2XbbskSUReTSmM0ShlMSpOtc6LgtGK37ZtwjAcz4tSneUuo2lKHObiXNdxkJZiyDgbuTAOZ3zkDqnmYQ6SJYcDdYYhlICy8o8dnmv8O0HpPWUm58tF89M/UmSirrEcl7Cf5pqnqo1je1ieRbFaIO73waRM1ErYjqLoFIjjVbqdgChStLoJnTZstSLeuBPznTvDi9goKkWLcqmAUVBMYlTJyz1+jMCyJD2dMV0oIgpABHE/wtEWxnFI0gClgUxjlXyk1txNJRON/cTRDl/84k/y1b96m8acRz3aAa/Bz37hM7z46tcpp4IwC5g+fJa1eze59uKLlMtFZk4cZjtM+D9+/wLnDxUJBgV2ki6/+vMfQ6WLFBpHcT2o2ZNcuHyJH//5X+D3fv3XeOyj55g78TGmT57nlVe+Q9xqcefSm7iNGf6vf/U1EiLKfgHHUjja4Dc8ylYBHfW5sdRnwhLM7CvRXekSFQRF26MnU3zjoLMQy/UwQ52WTgwphizRpFJSVIYgSbF0fpF4liLKQIwScQ05vV9KpLCwBaSeRUFLMqXor2+j/CImCYnIe/8oS0jJI8gzk29BdZbb6posz1iTUqLTjHc2d7dvp889PX7iCp0DYDa0v7Bte8zsffcAe/xURyCFRbFYHM+hgn4f3/WwbcV2p4vr+3zsE5/k/OOPMTU3i04zer2QKI5pryyzsniD3qBHt9vD81x8v0Cz2WQw6GPbNkEQMtlo8u0XvoXn+zzyyCPEcUychCwvL5MlKVlm0GRsrCyjbBchLYJBD88v4nkey8srpFnERL3JxsYGWms+8IEP8NKrr47bqJEnktYak6U8fv4xrl67jG3bfOYzn+HffOOb2FLR63Q5vH8ez3c4+8h5vvHNF6iUyzQmmvQGfVzXZaI+hevZ7D9ylA9+4lMPxXGNQWC42cqyjCBIcF0bMQzgGFWmjmM9tD0DyDLzEHVjZFUyfmgoOW7JR3O9PBzEDF0Xhkt8bYiSePyzCCGI03T4bBKkWqOGVfFHnzr5w/kp3Y4jLlzPePqsz+RkyuxhG9dYVKoxTrWMlJKkn2FKKSLJSKwYpQO2t1v0I4gCMTwoUHIFsQczviQWFi4J0uSft0VGSRSQJUncjzHaxpeGghIUnRqOq/BUShCGSAV2w4JM4XYg8z20ALeY0eqGlO0p2v0lZmaP89//i98h60f8k1/7+2wuBJw5OsPCjTc4te8Qie1RwOWrv/+/809/4zf5+u/9MbVuQPPUE2xtXOVjz1T43nc36Vtb/OInH+XGpdc4OD/B9P4Gy5s3KMw0wUrY3E4oTk8QR+CUSyjpYqkiPb3Kxk5Ezc8vEt9xURhcz6EkErZbMc1DdQKdcva0SxYn2JZNYEnqFghiCokkpkdJKrIkyj1xswRlPByRkVoWmgQnzZNJhNo9z7bQKJkf+wQgSUhNLsDtGI0YGLq4WDIlsiVZ0MKxZB4oKvKtnqMNKImdGVIhcFQe8WSs3OFBCkGcPczOlXYuKzBC5Cv9SBJmEdpAv5eTCs89fp4PfugjTE/PECUC23FJkoyJiSqDoIcQAt8r5ho+rQkGvdwSRVrjJ77n5yTBQT/G9WzK5SJ1q0qlXuHGtbdIjabbbuPazaHERuXAEyc8+eSTfOsb32Df/DyDwYAHy0sIA0tLS5w6dYprV69y7tGzfPeVV4kGEb4vwYJCscz29jYCqNfK9HqCNEnYt28flmXx3e+9wvzcHAsPFjm4f57FhfsUSz6lYoWllWUuvPkatXKNYqHIV/70Tzh+9Agg2bGg4Nt0BgM6vS7z+2ZJDVQbdWzPJzWwuHSfer1OFIR8+OM/xtZOm3q9juM441gjyGkYxhiKRXcMMjn4i+HfGRrujZxBc/uZUYsXRdEYwEbESYXI50ZCoJTczXjT+TIkSXIK7d5t3EhPqIbvFccxruvuMv7f4/WelZLtCfN3zxQ42LAplhyqNY9SNSdMaRXkSRxDvoldcPAcRZoooiAkylKKNhjXEPUyon6P7oamExi+9NUQzzb4StJolJmaqOJWHLKtkF6/jWiUKTsWRijSALo6xDKGcLWPX/fZ7PaZUIJQCmzXojnhY89U2L7dYStw6A52+NX//L/k9vWrbG4u8MTT+3jy/Pv5m2/9a57+4M+xtHaTZx99ljt3L/A/fenLTE02kDXB5r11JsqGtY0e0wfmOTU9R7da4dBsgywYkBmLweZNLGnjlAoceeRJhAhY7XQ4Wq5TO3oSpzrP229dZ2v1MjcvXuYPvvIWnrQoefkAsjZVoVSt4OsUghRpW2z0uwSrAYFMaTYquGmItiwyK8PJIBMSRyjiLAVpsGOLyNJYRpBJTZINz2E29EYegpEmZ9OiQJqcj4LJY6+Vyn2ZtBn6KBuTx4JLgy3zuPA0zfIZhFDEw0gfhhVQxu5Fe3Vtt1L6zd/+0zyNtVKm6PlobXBsixRDNAioVCpok9Lv9ykUCtiW+xB/ZbSpyUMFdmcdWZaNqQO2bee5c4wG6hJLCSzH5pWvf4Xr165w9PhxPM+j226TJQlvXbrIs89/kNb2NlEU4bsutVqd5fU1rl+5wvPPfxDIfbYvvvUmJ0+dIRgMmJmZ4uY717F8lwtvXuTxxx7j9ddfH3NzsiyjUqvi+z4HDxweSkzyyiRMYh7cu4uUktOnznL9xjUajX2srdzBHrZc5XKRxtQkcRAzf/gIW1s7LNy9x0Rtgna3g1fw0Rm4ns3c/AFSnVGvTfITP/0zQ0O90fExjO73HDTyj482Z1rnIm4jd9fyuT1uNExkscaAlv9u8di+ZJcBbsZzK8ivtTjN/z7aso3AaARSo3M6GsSPqrSPv+/MD+k8aWzSVgy13D/HKjgoKxccuqUKXsGHuJWjbxZiuWXiuE/BcWiUck1bEgzIZB8pfWKrQ9Fz+NCJJt+9k9P1w0TT60dkQUCrFVJThmSjQ98HN5JEicZ1FAWvxMSJCdKewK8VMIOYKApxUKSbMUGwReNQlZ17Gls2+f4br/PW977DfKPE4Z96HhcX4c2xcPUG5dkyCSl/+bu/z/H5CrUjUxw9/yTf+vL/h1fwOHfmIPtr8KB9h/tvR9xzBf3I4sBUAWFa2E4Rt2BRPTDPzvIdDj31c8hwBZ0YhHRzJfZAsxUIpCVwPIfMsamXC0zPNdi4u0GmJOUDk2y+s0IvDShOeByeqnB9eUDTsbEBtEVqJBAxMBpbWMhUoGo+7mBA2M9jrT3HIhUZRirSkf85kJgMSylcJEYZtFb5AFoKbFIGykaZlCTL17yubRGaBKP1MJFVYguRV01SkgznDzpJsI0k1e9K0QWakxNg5Lg9KBQ8DBmWsrGEHBP5Jpszw/Zj12R+RN7TGWiTopSz68M0bPGsoT3w2CYZSIdf29neYmZmhuZEjfv379Nut+l3u6yurjI9OUW73aZUqXB0do6lhXtcuPAmzWaTubk5qtU86jqMIyzLoTExwavXr1KuljCW5LW/+QEIweuvv0Z9okmv18MYQ61Wwwio1+tcunSJQtGjUq6RprkR24kTJ9hc3+Bb3/wmP/WJp3EnEqqF09y4fR3LMvh+kdZWi+3NHU6cf5ylxWWOnDhB1O/T7rRob2/jeR7RwPD4449Rb87yp3/yJ3zy85/D9/3cH2o8m8vPxd6VfpJEQwqBhVR5YvLo+KVpOgackQWK4zjEcTyuUkeglm/0yF0phmDX7/exXQcpQWdibE89oiyMfoYRT8kYMwan93q9Zy0lcPHrKk/UMAmuyLCcDNdKcEQGSUCh6FFwDAVfU5JlSq7E9gRSOpAGeMqmWrDx/QBpK4TMeP644B98pIJdtJiwFJNzBeoHpqgUwJmwWIkN0vVYTTLCkoWjMjo7LZxKBdoDPGlRKEjm9jVoHpvElGxqszXMRkq/E1JvlAiCgCBLWR9Y/D+/9Qfs9Lb58HOf5sd/9qcxgzZf+4MvUyxW+dn/5FexAsW1F/4aQQ8rg9bCHV67cJekb5idazAzP41j+ty8dY9B32Zns8MgSHnrhe+xcmWJV/74y0wdOcHyVoaHYpCmKN8l2tgmSyDshVh2RqNSwDeaZqOCiVP0yip+TUAGzQnFg5UBs8LgqAxDMgSKGDsDkUo0hiRK6LYGGMfBr9rYBQdj5b5AlqPIHB8jDVoaPGnhS0k29ECSElKRobWkM3Tq1FnOcckZABqlFXKYZZbHLaVomccyWbZNkiUYpdDkMxfrXc+7cqlGsVikVqtRn6ji+Q6FQgHftfOP1ytUayVsRyJVXtXZjsJ2xPhil4rxKnv01B1d1FLK3L5V5cnBEoOnbLSG1773KkEQ8IMf/IAbN24gpcXM3BxRFLK9vU2W5H5Vm6srVCoVAObm5lheecD3vvddVtfXSKKYbrcNaEqFItubO9y8cZuTp07xmc99jh/71KdpNpvoLOP06bO5k4XjoaTN448/zqGDR+j3+6yvr+O6Lv1OwMxkiV/+e+ep1i2suMSJAz0+++H9HDxycpjkq5mZ38fL334hB4Ag4NY711lefMD2xjrdfodGs8YLf/XXvPzCX3P06GH8QoU4jikXi0PZiBoTLPeCyGhWBJDoBGOyMQjtXfMLYciyhCAIxpywEaiE4a5T5OgcARQKBVzbwbHc3Dt+WCkFg2jYKse57ELnsWDhIBj6bb23ydt7gtIT++BECVwZ4wFKxLgYvHIBz3Yp+5AlIbZTw7YnkTLFlgmloo1SESXPwxZ9kk6PJIoxysVybA7O2cxPCGZ8i7nHj1KZbVCs+jgu9NoJB8sG2Qko+5J6ljDIbGbOzLO5tII9I1nf2mS72+P+3VVS4WB7RXZubBHHmkpFkIYRi/fvkCaa+lSNrYUdXnzjLoWawrI1J848w/1bt3DcjBf+8HfpB6u0tlr5elUnDBKDW3Vpb0cMui3M9jr7pot4JZ9+EFGq+lTr01jVBt0o4Nyzz/GNb3yDRBiu37nOzHSZldtXubHQpl5VHJypUUwVKgpZ29pkYa1DGBlaoaa/k+DGkvZKgOtmyJKFIi+ZhecTZIKoUKJaKuIlEEibsJ8QrHUJwpSetkldHykcfN9FxjFKlCnUSwzISB0bR/pEIcT9eFhhGEgVtUYt367EIo9Y6icgDBkZWufbEyUdHFVCDwwqy+PL0zQlGQYVvLv9F1JjO7skuVFb8HA4xO4FnKbpkO+S//s0TcetWhzH4xtDSonv+3nrYfRDgJWboqTsrK6yurrM8ePHEUIwNTVDrzfg5MlTZEZz9eo11lZWMMZw+eJFHn3kETq9Xu7XZQzhIGBnZ4epmWlu3r4FUtCcnKRcLmNEzgWSlk210eCjH/84R44f59jRoyT9vC1ttVpEYZi3pn5OCl5ZfYBUDkJZpInEKxi0rhBrn1PHI7xilUKlytbWBsVCgcUHC1x95wqpSTl2+jjHT53k8KGj3Ft8wCNPPsFzH/skteY0g14XKSX9IGAwGIzN/oMgII5znpJlOXmFJPNjZcscvEfnYyRczs+Hhe8XcV13DGR7W+YRv2jENdNao8lnRUmq0RlkaS66rZTLuLaDN/TpGlVGlUolpw+8t8rkvUHp6RlYiBSbawOsWOKmgrSToKMBrhxA5lD0J3A9GwsfaU/g1I5iqWlMLyQNAzphhCzWSXWRWlXRaJZQTkDJl5ythKRRQv/6Gv13HjBz9iwH33eGxoE5qnN1Dh2fp3RkkmJFUahXqcwf5Mq9AaS5Fmrf7CyWjsgqIIWPM11EK4dWt0USBRw8MI9xNP70FDO25vW3LpFoSaHq0+1uUVQwM99gqmKzudFlam4KKSycRpGDZ55BCWg0C2RZRrjTpygFk/sLPPXRj1D0DHbWJw5CPBue/eiPs3X3TZ02UT0AACAASURBVIRQLN+8yFe+eok4Tai5HkpmJFFK0Iog1ojBgExEeFFM1RMUZyVOxaIkVe4WqQSGFBVs4yqwkwGDQQ9ta6p+SqEuceoKx4qpiRQ37iFNRDTYouxo7DQg7sbYUuEYQyccUCzYNOZq4PlEoaakbQIUUSSoOoKSIykKsO1cpFmuljAydygbpF2Usmn3Y3qDjMRIbGWhrJGKavelh4BjO+ohDg0MzePTXQJfHlboPTRPGhH+RkPTUSvgOA5JFKPTBGePjS3k26EUQZylXLl6g512m3OPPsqtW++glGBqZoZHzj/G8x/6EFPNJjev36Db2uH733kRX1k8/r6nOXbsGNOzs/lNaMhdHeOEy1cu0Ww2WVpbBa3pdTpYUrKxscHS0hL3FxfZf/gQb7z+OotLD4iThNnZWVzXpr2zwfz8HKmEr371LsVSgGCAZXdI4mW+9vUl/uLP/oI3376CwmZx4QHVco000Tzx5NPYjkehkFMIdKppNBq0trZZX1mFNNl1nRySI0eV0mhGN9qUpWmahxBIMcxU3D3WozZtL8Vgbwu216HTiN0AgFHFms8ZMyw1NNMzkizVCGlhBLium4Ob0Qg1jFSTNu/1ek+e0u/8s3/+peMHXOLQUKiXcMpQagpINF7JQ+sk121JQRYr0uguaZKRpS2EdOmHXQrVJtFggDQZXmWkWE5ztmgvop9WcI7OMLi7RlK28ExK0OniT+1j6e46trFonN5P6/Y6hZJgoumx04+QWNxfXGFqqoEdRQT9iH43YKvTpuhX0Al8/ue+wK3r72AGEeuRwyc/+zFuvPUGQWuTB7eu8MyPfY4o2AHlk7S3KTZrRN0O0uTVTamk2N5o4ZeLBIMYWykilTE1UQYl2NrZ5pkPfZQszLiztsHd24vYacgb33iZy/e2MFHEVNkhU5qSb3BEbtdbshx8T2J5uQ7MzgAMxlb4nk2QSKIMpg/twyoUqM3UCaIk9yJXHs1mFc936fUiet0M4Yl8OKiLw6jvPFpJRnnMuINAmBQTG6SOUL6N8FxMnFJplIilQNo2qW8zEJKJqSZpe0DBtYk7CdJzyZTGLzpklgNSkYQhSQzV6TpLG93xNfPzv/Qr4wt7rz9R3iqIsY5q79N4r1ZqdHN87Wtf49ChQ+Ovi+MYQ84cTlI97AoMmc7bDpGC5dgcPniAO3fv8GDhHtMzcxSLBYwxrK+v0+/3WX7wgP6gS1FZFEsVPv9L/5Cjx89w4tEnKVUrTE1O8uD+fTqtDkpJpqfn2NzeYm5uH1OTk7z44rc5cOgQBw4eZHlpiSxNWVlZyQMywohut02v22Hfvn20d9p0Oi221rdoTE9y4eIa1663Wd+22NzIKBSKbO3sgDYMwgBLKRzH4ezZs/S6XdIkj1FaWl3i0fOP5dVKmhIFAY994P0IIcegMqpAd+OsNFmmdwFEyjxTL8uGvkcCpaxdt4ZhxTsCob3vGUXROC55EIXD8yjQxgyV/zkXymiTb+d0itHZWLuYPzn2aBuV4OBM/YcjT37tX37pS35qqFqGQjXFrSkSIfHdKqmRxLFCWxHxIKMXdnGCDGM8jNRY5SKFYhM6m7iFIo4vEWRIKyVNNUEvo9VSrPVsbAxBtcjO1jbVWpmwE5D2EyZKJfxpF73do93u0DeSomuRrecpK1MHJ+jdWKfbGVCa9mjtbKMyGKBRZYupWpOw26bUnCLqtfmN3/ifOXLmAGUyLNPl6IknIYrJfEnNtondJrXJAn3XY/vBbaIwodFosLPTImi30dJheq7Az3/xvwJT4OCpx9jcesBWP+DJx36M9Y13uPCDt/nWqzcIg5RqyaZSVFgaYMhyHZLZQJOi8IwktBWluSZ+scggcxhowUY3xQ4yqnWb5btb7Jtvsna7S9LpkyUO270EiYXrWnjCwfbLhFFMuVxkkKV4tsF1c7uRPPVFkonckjTLIBtEdDGIBFxb4pQrFHybwWYL0+mjyja9wQDLttBZhDSCQslhaa1LNctj3Cfm6izcWaWX7Nbj/+E/+EdjUBrNLEZP7If4SMPWbfSEHwHXaH18/Pjx4aA2GX9tLomQWEphKYmSw+w5qXAsiVsosrRwF52lDIKQI0eOkCQpQRTkMghjyJKEyXqdoDegXm9y/PEn8htMZxRLNf67X/+v+fAHn2dqeoZyqcyBo4fp9fs0q3Uq9Toz09PEUYTjuviFAlEQoE1KFOUq+TNnz+EXfWzH4eiJ40xOTxP2A/rdLpDzhIxOabd2KBQ9PM+h6DkcPHSILMurnpWVFbY3NgmikFq9TrUxQa/b5ZFzj9EJ+kxMNDh15iyZ3j3uIyb3aKgcBAFRFJKbquUC4LyCcoa+5fKhdnpUdY6AYzRXGs2QlBwytclzHnWmSdKUTKdkaYrrursGfXsALslStNk9j6PveWj2302efM8xuG1nNGar6P4W6IzgjoVyQgKzw+Th0+DalEsfQJYdVFagG4YUa1O48UW6vUVkuIrjF7DsDNe4RJlk0E+QyiDtFMdVbMmEWtinMtWgUhZcu7TM408dIR4G+PV6HTq3N5l+/xl6a1vEnYxStUS00yK6FyJnXRgY4m5McaKJP4iIjc/5I8f4yCc/jvgmFH2P6al9aJ1y4/oWP/uffQZjNuj2u7SE5AffeZknzp3j9NHH2FjfQrXW8c88xb6a4Z2r1zg00+DyC68zOV3iU//Rr1CtTdBXKWl7k0QHPP7Uh3n52/8n5XqNuqVJXYWtDa6XE0CJNDEZaInnuSQmxKlMABmryx0KtTrSSLrbXYRwWFloEycZXaW4+TdrGJFwe7WPEIKIjEp7kzNzU7R3WlgFh+1+StJJ6OuINIFOqik6guZUHSu16K3vIF2B69qkcYJRFqsB7EsUUSFESY90Z40000zONIjChCgIqE3WiVsRcZJiGUG/G3Kg6pFZGsso2jttpvZNsXJzZc81YzMYDPA8b9ymjS74XUHu7kB29P+jGwLyAepoM2RZEq13SXtmqLPKknS4JcpdNI1UzMzu5/XeX7Nw/wFPPPEEL730Eh//+Me5cmWRZrNJnGqqBZednRaFeokv/NN/QtbPk04gb03+2//lfyXWgksv/TVCKjY3tnj6sSdY21hn4e4dDhw4SBiGxGFIpVRkdnaW7e1tlLA4dPgQ71y/Spak1CtVlhcWeezJJ8Zt7MHDh1hYWKDf6VKtVhHaUK/XaTabrCyv0Wg0qNfrLC0tUd1fJxwElMtlSpUKdxbustPaYmttlfqJU3lesk7HVdAIFIQQMNyiub5HEqXjrde7xbUj8BFCMBgMHjoXe6kYlpW3YrayUEIOk2LE2NrEcnKveMuySLJ0zO62bAtH5M6hrp3/d0TAfK/Xe4JSyRLE3Q6eY+FbRZAppbJHqhXG6mPJEnpwmSw+SJLdxnPAjQVxr4evLXDKaLoIYaFcsBIbX0rS1tD6QiqKGpxK/stv3F3lzKlJNpe2cTOPruliWn2yzGbt0i06QYJVKeKqmEAkeNMFov4AWxmCeECSFvjU3/1HfO2vvgqWzYPFRTqtLfpdm/XVRfYfOcDP/8ov89Ibb+NlDWpFWFka8Nkv/H16ScDhY8cRwmU9Dvn08x/l8o1XsGcPM1i4yMxUjf1HDyGtKq+8/jITM1Ncun+XD/7oF7n69gvUSnP8+V9+k+2VAU+eOMH3L16lMVPHsX1aGx1SNIWyQ2Tycrmz0cL3fQ7sL9LpGzZvbhF3E2wv4vy+CqE0bC63cSQEJneB1DLDMpK5RpGtQUSpqEgsm9oEGB0zEUuSzGamZkGa0Rt0md03izs9R9qJiXoJZtBGZbC/ojAywVVOvpERGoQi6fbQqcZW0G91INZYOjd5cxwL6VioJCXKUmwlEd3uQ9eMMWac/bbXe2c0MxrNK8aK/z03yOhzaZzkbduepBHIn9Cjf+s4uwNZhuZ1/V4LpMO5UycJg37uwJgmOYsYKJeKrLV3KBeKfOgTnyXt5fathUJhPMsKAknRslh8sEG7tYpEcunNC9i2RRzHXL18hfc/+wG+98orvP+5Z9EYTp4+hRq2UkJKisUiC/fvcvLoEZIsxS/5HD91nOX7i8w2m9AwKNcjCAIqtRoamJqdIYgjpCXI4ghpNLV6hSzLaDabKCWpVqv4xTKVSg1v2LaNjuPoWCRJMj6OAjEEdb2Hy5Sfh9FGba9o990pMqNqN0nyrLhM5g8Kz/P2tIQpJtulDuwFNZNptGTsASWUHEe2/9CglIqcFFmuOnhlRcEVeDWJVa7h+A4iVQg7xLJtmqd/iUMf/ixIl8tf/gz9YAdH1nIzQZWhpUDHMYNuRCIEg1RibMHK3W1K/Qq2HZAlcPPuKgXHxlIdgkGEbytaKqFiXCqOwUq6ZEYwoQRx1gdborMUz3Hxq1X+5mt/xOmjB/nARz/FrWuXWL9zmY/92GcIJJw89BhZCgv3rrJ+4ya87wQT+w4wf2iehQcb3H7zVWonPsjczgYX3/kuNy68xaRMKDZnmZw7z83L32bqzj1Wb7+G4/pEsWTx2qtcv3aZhYUF0q7k9NPP8OD+EjaSYDNFxC0cJL1egHO8yoNBGy9NKPsW0sSstQwzkx71yhzLK5ssrnS5PYhwJIRpLudQUmBkiovk+HyFzfWASt1jYSejE7YwOjfnt9DYlqZRdylYDtWCT3tti7gvsDw7T7SoeUyUaizdXsRBogr5cDoPBtOk2iBlruy2Mk2mFD4Ge6qZb2t6CcEgQjj5liR516pkb+sGux5Iey/0kVpcCJEHjwoxlsNIKbFdZxznbtt2HiGtFEmWEqfJQ0BmSTGO15JSMnf4GIu3b0CS8FM/9VNorWk2m0RRxMKDB/hO7oFenN6PMYJomPCxVwcmhOA//sf/Kf/vl/8lnVYHrTPK5TI3b95kbnaW+/cW+MCzz7K9tY2Ukm6/B9rQ7XSoVKskScLZ0+dYXV1G9fMsuu31DSZnZ2g0JnnzzTcZtFaZnp3l5s2bnDt3jlKpQrCyxNsX3qToF9je3mZqZhqtU1aWlvL2db/FSy99k6ee/iCtYb7dqAoNgiCvQOXQMwnyRBvLQog8st2YfDA+oguMhtmjRcOotR6BW5zmx90RFskeAe6o8ovTZLctNxqJGB9HgSDJ8spo7BQwbMP/vUApEB6ZVkgXjDJYRQc5TMm0jcCuFbAsIL3Nxtv/gtat/410sJzHcdsKTYs4jjCRg1QRSZTH/PS6KUqDayQ7JkV127glFykNNSCL+6TGwheSVMdUixJXJGhlyAyIUBCSkmiDsiSuZZMKRdzuM31kH0urbabm5rn00p8xe+Q49xdXOHBiH8ZN2Llzj/nZQ7g4vHlzgeTSLTr9r/Pf/Pr/wG/+xZ8ztz3AjjaYfeZHmWxcpjZxFC1g/fo1zh49yJ2L38Yv1rh5b42DZ5/gyqULfPeFG1gVG2eiycd/4if557/2axwq1wjW29xTFsLEVDND1A8pdzKCuguOJOmHWEnGzsoATZd2PyGLoWSDlUQ8emqapXe2KZRslF9A2RapzvAnCtzbGBCkMYVM0JUptrFJSTFRwHpHYojIlgxGGqTO8KRFJDJ0JiiJHidPzdJb2yJLc/2aygSZp5C9mNgSKE+TSQvLaGItEXGCN1nMB8p4qMYEg401BjsPu3TvZf6OqqXRx/aC03jbM2wBpBDjVbFOM6Slxk/osUUGoGw7d9UctoA6zdA6/xmiJOXoyWMIEXD1wiUyqcnilNXlFW7dfIfjp05jCc3PfvG/QKncF9yyvDFLOQiCseau22vT2m6R6pSDhw+zvb3NJz/9aZRSvPXmm6xublL2fVqtFqVCkSRJmD9zhsxoSkWfK29fZmpqiuXFB9SrVcr1GkIIbt+8TrVcpFougpTMzs5y58ZNbN9DZJozp89RKnssLa6ys77JkRMnWVlZ4ezZszxYWuFDH/8s73vu+YdX81oPJRyjLSbjB4JONbatyDBjsBkMBhSLxTFdY2T4Pzpve/24syxjMJwHCZW3dJ4z9HQykiAKx+fUch3SIfAIIdBGE4e7ldtoY/feO/+/ZdD9h7/5z75ULQsskWG0xnZsStMFTKaQlsCkGUoYwn6AFF0cJxdtYjvoNAEysgTSFJT06PbapMYijjOSRBKlNt+52qHiOxSKFpbO/VeUbWEPtVWWUtiAUBZSqjwlw7JIdYorFRqwhMYoB7syyfr6OueeeYq3r7xOY3KScqFIY3qKuckm3U7CnbuXcFQhXxXP7+fQ4XNIJfnjP/kdmlOHSNodJg+eZLC9yfzhY7zy7R+weusy5Yn9bG/F9HoBa62QThzw9mtXSUwJ7bj85C/8Ev04RLgOf/VXLzLIYvpCUSw4mFBTcSxam106QjJZKRDqPPPXV5JEx5gwo1CZoFEX2EpQna3RWQmZOzPJ2kZEyREEUvBgs8/KzgBbC0rSpiw0Tz99ks72DlZiSIVEpZr9UjG/v0iQpZhIkypBOTM8cm6OqaN1SpYgw0K6Lm7Jp3Jolqgd4FQK2J6LV6kx2GwjtUZnKb5XoL/ZQpYKBLZhY3Mbv1AArVkb7DpP/sIX//FD25wRII2dJ/eA07uZyJnOkErmQY175Aq2bef8GdelaOUsb4ZtoZKjxUHO00sygRVHXLvyNlmSEQcRvW4H2/VwlOTDn/wsyvHRenfIniQJjuM8xH2SQnDt0kWefuYpkiRhYWGBO3fuEIfhcEAvWVpe4vyj59EmJUlikiRFZxnbW5tkUczayiqu69KcbLLTamGyhCiKWbh7L3efFJLN1TUmGg16nQ6+Y1OuVJCOAmlx5Ohx1tfWOHf2LAkwf+Ao7//Qh8fV3bsfBlmmh79PjJQW7HHuHB1v27YpFApIKYnjeOwOMKIO7B1W79WsOY4DxqCGliYGSNIUS6rcOE4psiRFWRZKWNiWygMihvKkMAxzqoeQKKk49B4uAe9ZKUU61zwlqUXJdsHRhJ0Y6QpM6uLZEa12jJQakRnCVh9DhE3e76ZxSpqA43gYW2GUTZZkGKEw0hDoNCf1BQbVFJBqsBW2nVdUOk1wpQNS5mxUmYchkiZ4noeOklx0qhwKBY/TTzzKZr/H8WP7uX3xDRSK6QNnIemzsbxKa2sbr2ShQwtkHj+9sniJqeYkfvXTZFFA0r6HW2rw6ivfpfPy3+A5RWozp/COnEREgtXX3mI76jJ76BTHzsxSm5vh8vcvUixXOHH2NBd+8DYHG2UKSuIbjeomZD5UKj6lyVketNcZAD4l6AQsiS7bg4w0NHz6eJlb6xGFkqIkPGRNs7rY5uBkhYV7y2wpB5OmOFISqAyRJBw7MYelDOcenaZ3P8SeLPDdi0vsxCleq88jsxUupTtULMFSz7C5sEO7NaBSU0yenaWiXbq9iPblBbxKCcKMjknwXAu7kbOeW90YbWK8WhEd5v7etVqNXqeL5/7bN8dISjACoNFTeK/t7d6h60jgOboJRkPuvW2gEHnkdzcJxwNYIQRhHOXsbstGpim+JXnz6mVmZ2f5zndeZnJykvm5fUxNTWJZFqfOP0Gv039o8we7w9fR+6ZxyMEz59hpd2hMTnL48GEmJyfpdDpcv36dU2fOcObcebrtHdqtLp7vIhHcuHE9/9rZGRrTUywtLpBEMUU351zdW75NyfcQOqPbbWPbeZWWRxw5RElM1tN0trepVqucOnWKza0tDhw5wrFz52m1OvlAOckZ+lrrYVR5DjY5b2kP+33PDGcExFmmc6O84TxtdA48z9t9QAzPieu6Yy6U4zhjHpccVqr20Ps7Soae3npkZyyRlsLOLCwnf6goIfPQ2L+FPPmeoNSLDP0+NMuKQRDjDRxCFVMqVxj0O2ROCewcoaUOsL0S2nikcYqFT6b7pDpBhyGOsNDCJzMdhFJoowlDkJ5FqvLkVOlKJJosGSrMjSIzuY8xSGxjSIRBWAJLZ2hbIWKD9iSCKrdv36ZaaqAKZWr1Au//6Oe4/IPvUCnVaTRKxGmXSq1BL1rDFW7eIoQBR06cp9tL6eys0lc9UuNw9PRJ4uQUBw8f4ebdK6zdv4dqzPOpX/xF1hYXuXnnCiceeZLF1Qd04y6X3rpIa2OR/c06V7Xk4GyZQRagixm252P8MqGCoixSrTrcXd3m+ONzmAsZ21GXVAle/N5Nju2fYurEJPQjZCawOjFJN2Lm8BTnZspsXt+gerBGlEjeeGeR168v8z49g5qA8vEy65e2mVSCtoHrOwnFqI2FwFeCppULI7dsg9/LUBS48L1b9JTGkopye5UTjx/DzjIy20L3QxIyjhyapLu6g24NEIUCqhsTWiGlmoedWsDOvwVMezVSe0FoBFR7186jm2DEuRmRLfdu7fLoJoXlqnfdaJrM6OFMCaSE9c1twkGPZ5//EI7jYCtBZgzttQ06a12EpzBGEEQxEpEP8IfvOfoZcB1+9BM/zp//69/m4gvfxiv4dLtdgiBgqtlkZWWF6ekpCp7H3Nw+WjubSEtx8vQplhcWsZTi4KFDnDxxmhs3buEVC1jacOaRRylVyqytbmHbin4Y4Ls2S0tLTBU8omDAervLydOn0FnC0sI9HnniSc4++X4y5SNFnlycO07mlWa1WmWUSrJ3HT8C810picUody0Zgvvo2I9EuHu3onGa5Kz+0WJCDO1LjEYiUcOI9TiOyczunHD0PaWUGLXbvqc6fWgb+0OBUkuntEKb4nbA1IxNtx+hSookGKClTygVviSP5TVlsiRACUUiBIKEJDNooRHGoRdowiBCJxZaC9LYZm2ji8wCIl1EG3CkjdExWmgUFrajybRGSujfG+DOemjXRukUaST7jh5lfXuNoNth/yPH2er1OHLqFHdvvMPx/aco2x6lwiS2E7GysUkS9uluQS8OmZ09StjrMzVziKC/Qxhr6vU6rU4RYQnCYIDtFHPrhSDi8Mn3sbyxymuvfptyqcDHfvQnaG+3Wb39Nh/7kR/h9/7wjzlz6gRv/+BN2lHChfsdkjjGtyXzSlKdcrCrDnEmWN2IOHZwmsF6j+Zck82dHstpbiFy5f4ad+9v0rcSzs8XKWub2tEqAyPxXMW+Z2a5f6vFylYXoQ0Tro1VANfz0IHFWiegneU3/kFlUfAV3mSFOAoou5KFtQ5lAZtKsfr9m5QsRRWYnvfYXNYsruywvNaiKATNZoniRInB0jZ31/LWW4kB047FviePsXl/nSDsPHTNDPohynOw1O7gQGeQxAlC5mBlKQdl7d4sI4mCcHcroxGw7dW8jWw19prXK6UQOhc+gyaMA+qTU/j2HA8ePCAIAo4cOsDW+hY/88V/SLcbkAzC8YzDCMEgjLBkPqQdD+CNJE0C1u8vEgQB3W6XZ59/jpdffhnbtnn++efZ2dnGkgpt0nGlsb6+zqmzZ6hPNFnb2ODjP/NzPNcZIAwUSvm8yrU9siwhGkT0W1v8xR/8NgcPHyUJIyYmJjhxqkyn1cayLC5fu8kjTz1FuVJlp9tD2jZZlo5lOntbYK135TxmKAcatW6j47hXd7aXrPruh8CI7S2EyLdoIwfRkSia3C6XUWuuQTlqPJ8CMBkYMqKhlMV1d3P2fmhQWm4b9pUSIm0xGEB1wiNJbAaxQXkWQmvCWGLpGCEMOnPQtoWQkEUpUhnS0JBmuV2GyEAbxaCTsdnuc2czJMMiSjIMuZYGW8EgQUtDkhgsCVLaVA5W6DpFKr4g3umDE3NncZWpQ0eozSniRFP0JddvXqQ5WaFee4wokWxtr/LoM8+xsfYalZpPp9XFsz1syzDZqCFsj5WNDjIKWBcOpWKdOArYXl3E8UoEQZ/m3HGEtHBEwqETZ9laucWr/+aPmJyZ530f+QidrTZPPfYoaRiwtfKAUgQBIUZazBubySNl7GqBzoNNvGqRRsOiv9nFlRk3F1vsGIOjLGSkmcOwZBukUdxZDAjp4TzoU2s6TAmb6rEGZam51wsxwqILvH5tiyTNaNY8jCfYb2xiBKWixCpaKN9mZ7ONKXgcOd4k3umztBWSWYpJX1AoemR9jSo7WFHA4YrPUifk3mYH2YpwrYxY5E4DKs3oOS7f/8F1tB7a2e55eb6Tz/ksK4/ayjKydDivkAJLjkzlE3RmofVuWzfoh9jOwxKSERBJKceWIKnOxu2F53n5AFYIQOG7giee/gBf+aPf49iJ47xz9Rr3Fx5QKpUIBwlS5jeHJB+yG5Nb1u7dGmqtKZZK/Nnv/ha1qSnuPbjPc889x8WLF6nVqjz//PO88cYb7N+/nyxJsZRDoVhm7uBRjp16gvt3rnLt+nVsz+HFP/pD/s7f+wV2uoNcliEkcRzmw3ujefPiBXZaA+IwGPOOFpeX8DwP13U5e/Ys169fp1CbYt+hY0RRMhxIa6S0hu3QbvWZWwrnicOjAXOWZfQGfcQw5gihESYfeo8y4NI0HZu5SSlJdTb+POQV0kj+M6rCHgI5MSZ9D79v3uEoHCwFytqlFvxtoPSec3BbWHRC6KWCSBvavZhOKyZLJSbW2MbFFqCDYBjNHZGFHdJBDy0H6NTFkG8F4liTpQIjbVAOrW7Kja38l7Mk2EJhK4mbaYw9fAraEqfpUap5XLvdZ2qmSevNVWIZ0epoRAG2Fq7TfnCLpRtXKFd89u/fT702yZ271/nGV/4VTqHEvWuXqNdt/HINpzyJ7ZbRWrK10+fGndvEYZt+f51+dwUpUhZvXMH5/zl7zyDLzvO+83fyOTeH7ts5TE9szGCAQeAARCBASiRFShQlW6YoeRWr1nLtlr756xaq7C1v8mq9qi17La2WXluSRXm1EkXLFEmRFAESgYPB5OmJ3T2du29OJ7/vfjj33u6hLKiKjUKha9Bz69zb533O8/yff9AlmoyYnJzGMRSEIgiikGK5hKroHDtxBiyDS999h+31LbJ5kzDoMzmZY9xU0WODOSfF9EfmsZ08D6/skp3MUzk9gaaqlJ6Y586tFq1OQFqRVFSFkqqSyaWZ15IVHBrfugAAIABJREFUa1nCQjGDI0J2aj7vNxpcfmudHzysU9B0nj4+BrEgRKVUcTgxWaJcyXIgVTZ8j7W6z+21LvduVZkopxjvBjxYrVPzQxYrGdpRxKO+ZGfHR7VVMoOtSyZrkNUhjeTMXJannprAkQq6VKiYFmlDJxYSTRc8uTD52D0jlcFI4CcbMxFDKGKENmjrRwzixI9bCoFQEjuVnuciIok5sIEdFqujgYfDgzAEpT3PI4gi4gFruNt30ZwMlp3ixtXbnDx5mnK5zPnzT0MYJzABymAEGvhLH8G9fN+n3/fYP2jgux63blxDVzWuXr2K2+tjWTbf+ta3sCyLeyt3GBsbwzAdPv+FX+GJ515i8cxJ1h9t0HNdJirTlErT/Mc//HfsP3wwwtWGxTSVSuE4FotLi6AlYHC/3yfjpFhdXafZbPP+pUvEYcTG2ioiPGRGx7EcKfF9P7Gs9Txv0NX16Ha7ozhyRVGwTQuFxBJGN00yTgrdNIgVcH0vGc2OjH5DIe0Q4wuDRP3v9jzCIMZzAzw3IAwG41uYXEccx8nvPEy6OEmAkBGBf0gF+LuM3j50+/YH/+p/feNRO6Bka1gKpGwTUipaJAkUDdfzUDSNKI7xIwUUA8VUsawCYaig6BK/HxEIQeAG9DxBu93E7avsVwO+v97FUAQF1WBq0kbXFCIkhqGRsSx0W+PW1QYb9ZD5vEan1qCfSzF97hhW1yMlYKsb4/Z6TIzbFCcWUE2D5sMVetV9suk8x0+eZ2dnndnjT1PIplk4fpL6wR5h7BFHgnJ5murOI6pb65hOlt3NdQwZY+o6Vr7CqScv0G316Pe6yFhFCI1H6yukiiV0TWNqepq1+7dRXA8t6OBHXRaeniJuCvZabR7utNk8qPGRl4/j7rXore9QPjbF+l/fZzMUCFVlWmgEERSLNtVmH19omJpOF2h4IbpMgkEXTIstkWw4FnJpbCvCymaQvS4ucG/XIy09Zh2D5XMzPHrUYz6lQCxYbXhUA4XTZ8YRWshG26cykeWJuTQPax6NrgtSpZCx2eq6mEaaeuDTbfeJQ5WeGxOqkryuokQxRV2nrcWU8ik29w9HuL/3i7+OYZgIESW+SAMcQh2m3WoaCon7YYwAmXCVpBAYmk4qk0SHHx0zhk/74TgyPDzDEUxBJB2XiInDiLRjc3J5GUOVVA/26Hk+rXqNiaVjOHZC7AzjCCkhjGKkkARBCCTOirqeJKpMTEyycv3qoBCA64U06g3OLJ/BcWzCwCOTyfLyT/4c7U4zGZFQWTp7jpdefo233nqTnZ0tZmdmuX3nNvdWrrG7tcHM9AlimbhBHj91lj/8t7+LY9tkM1lqtTqtVpuZ2VlSqRTFYpGJyUlq+7vMHD81Ap2Hbgr9fp9+v0/o+bi+R6fTGYH4/X4/8XUSMUIKdE3FMk1kLAYWxTEiSq5j+P6lGASExjH9vp/Y1wCGoWKYBoqaeKkPt5YJlqehacYg2Xgg4lW0RIIyIFYON6TDB8uPnPv2+//6n78RhzrS87AsjWzGwDR0pG3hGCqmY6FpJpl8HnQFyzQSIp5MYocVdEIvxmv38X2BF0QYRp5mzaXeiWkc+LihSiqtMZFPo+tgmBparGDZgtUtl7RukR8zkJZJLjeG1+tR3eokKnlbI2p12dhukc45yKDGsXMvcLB6G6tQwk5btOot5hbPsHb3BtLIcfPSW5SKBaoHuxRKk/QCl9CPqMzO065vE4ch+XwGDIMLL/8Ed698gG7a2MUStm5Sb+yjqjqtgy1K5SUe3bzExuY2YzmFjduPMMtFFNeluJBjejrN4liRiq5x7fI2DzsuTV9j5eYuVTdCUwWTsYooGtTimNATtKXAQjKeNpiezjM1W6G+VaelSfBADBJcGm7IQTNC64dYqAQ9kVhtSB038tmvuWSViHLJwLIUzBDmpi0e3e/Q6WjksjoVLRFYVtsx5xdSqM0YiMiP5SirAbalUlItyjM5dlo9irqN7wU4hk4YhFRyadb32/T8w9juX/1H/+0IT9I1A01VH9ukJf8OblBVRcRytP7P5tJ/wyrjh/+roCHiJIdQxImuK4riEVibcizC2Ge/1ubNr/0pICmVx/Ejwf7GJvMnT46ihWKRdC0cGUOScVJg6DpWOsW9ax/geiFBGOJ5iaFat9eh1WiiqBqb2xscW1rE9SEc+FMrqHR7fZZOnuH808/S7rR4/733mJqaYXPtERo+D+7fZmbhGB3X48SxBS6/8w7dbodUKkXPS/hSBwcHnDx5ks3NTWLfY/nCR9AMfTQmDTPgLMsijBP9mW2nMAx9ENFtJxuwAVbm2IecrDiOcVJpVGUgrB24CyiqngidZZyEWjrO4GEgB1u3Q7qHk7KSEEsjCbiUA5ct07QTvEtTkiinQQEN/IikNkmOz/7tsd0faof76omyPOi5dJo+ZydyLE+HlPI2mTGTtKZg2BpKFGBkDAoTEyhqCiyd2O+hCxCxh9sNiMOkWkehYL/m4nmSWi9ifU/wrRsuJ8YMTs/nUbMOer7A5csPcVodTF2DUCU9kWXxtad58M4HpDWJohjEpoLd9OilDIwAMrMlVDNPp7bD1NwsiuYxu3iBnc1VtEjHqczSDdosLJyk3dxGMSeQ0mWsUqbfbtJu94i9fbxel0yuhMxVGJ+aZuP6ZYqFcfZrVT7y4k+w/ugOfs8FJeTu9csDI/0+UgR87Vt3SWkOS0s2c2M5VrbqrO5EpCNJpERYuTTHbZ1xRWFfBtR3PbYsjVgIyoqJJUMsNYWeEpz92BmkreButShXpth9sE7hWJHtex3u37jL8vIiXqPD+n4L3zIwrAiERqMXcTKXhV5Aaspkp9dHFSY5W8WtehwEEOkR006KUy8tQRTR26rSjSOymTJBFNKrHrDdiqlMlYgOGqT1CC+TZX+3Ry3yUYTBfFolaxhs9HpstA/TTL753u0Ra3joryNEEvetqhJ7EKM0fNof8oL0kcHYEJgd6rHS6TSaruD7boKjBDEoglQq9dgGSZEJLhnHMY1anW/8yX/g5PI5rl+/zlPnn6EyN8XY1ByacggOJ8VIDK75MG56iO/88e//Pq36Hm6nO3KT/NRPfJJms4Hb67O7uUVxrMyTL76GrqsoGDi5DKaijVjQzkAS85+/8ies3b9DupBjolyk1Whx/fp1UqkUU5MTiDCg3/cIB8LcfCFHFMeEocDUDX75N/8JMOQc6YPP9vCBMKQ4jCxo44goCB8zctM0Y7DNTMYo3dQe29QNX2dEVtU0fN8FqT9Gqhxib4p6yDvT9cHKf+CzZdnJzyJ/aFsax/zEy+f+Vqe3D+2Ufue3/tkbuqKx6QlmbAVTk6RsBVVAqIToqo6WMsGwCIIAp5RPOEu+QGqJcX0QRqiRJFJCIj8mdl1SKQPHUSlaOiYJKXP63BLvXN5kwo4pWGAVVFLlHOmCjTBibn9nnSd//AL37+9hmxLT0AgNUBWVSEbY4znidhVbUek0u0SBRq++jdtqoukmJ586T6/a5PmPf5Ir773NE0+dpefHVHcPGCuXSWezdGs13HabqVNPk9IzbN96n8nTy2zcuENlfor7H/wVfqdNPquys7PO3tYmGS3k6q091tbqzJV0TsxkKSiCazd67AYuP/X6AtOqzlo7wO336EURJ5YmqcxZPNry8OOEkq9GAk34nJopcOoTT9Pc3CLY6xHUmjx88x792GX3bo2FCzOIrTZTJ8fptNpYXgy+4NjSNClFZ6/dRw1CCoU00g3wmiFnz0zQ2miyH8OYpTKXFdTikMLsJKLTpX1/H+HqOI6FnbWIqj1CEdNuePRQWO34PHn2OHbQJ2M7+DKkJyS7bRdPUfHDw4Pxi7/2j0c3uGlYow2RpkpUTUuCDUlsNcIgJhQCPwjpeW4ifxCPs8GHwGoUxaRSKSCJmx4WNdd1R0Zxmq6POp3Ll9+jVU9GoemZGTzfZ2ZhIRlZRJKu0u12GebQ6bpGFCUpt4lRWkgQhDz97DNcufQux48t8ujROlEU0m61WLl5G8PSqNbqjI2NcebceTTTxjZTSCkS2xGvDxJiIWh3OszOLZIvFOk2mgS+x8rKXWamphCxwLJtjEHBaLZaLBxbZGd3dxAKYIMUXHz19dHGcRidZJrmyKjtaHFJukoe+yyFSMDn4d8VCAI/IggSUmfgh0RhTBhGRFFMGEREYYyma6ioiEG3yhEmuWkZA2xQGRQkRtfg+wFhGBME/qhbGo7fpxYmfrTx7Xd/+394Q0Oh54eMa0k7l8kopBwDe6CxMXSBoRnkxsewMuNY1jh+7BH1AlQGWibHJAo8DMfAstQkR16BTAZsqdGJDW4/6HD2RJYo6qNoBopl0WyG2JrC9l6Ik5b4qRzKQRvTlqixwJBJJE+hMsb4ZIUwiCiOz4BQSDuCRr2Dpasoqs+9OyuU5qZZvb+G9CTXb15haekUzdYuacek39glFBGGlKTscdKFDNVYkBYpskUNv9slndbRoi43VzYIqnUytk2omRhaRKMbcSpS2dp2uVPv4auwNFMgpWj0qy7bvYCyqdKLVQ722uyvtiliMnUiRbflc/GVBU4/e5oH93apXVtlbGkerd+n87BFX/rEriRFRORpTJybY+U7dyiOZbDGCtilFLm8yt7KJi9+8glKhXFEwaC+16cjYpoHLTKKxp4XUFlwmH3uArMzJdrr29i2gteMEZHP1kaVydMTBH5IZW6C6elJJhyL+YUKodcjtC0e7VSJY50TUw5GK6Zsaex6h4zuX/y13xjJFTQtyXMbem8nEdwaYSQSEq2U9P0kONPUDGzTxLKsEYg9BLeFSNwsj3KajkaBqwMsxDINZBRimyadep1CvoDneRQKJba2tjh97vzIQ6jX6yGlHGnGfD95D/1+f3R4giDAdT3atX0e3r8HQhJGAdlMGtdz8f2Q8fFxDNNkdmmZyA+JB2EHumGgaxoySsiGkYiTh4iTQugKd27eoVAss725TS5fpFGr4vk+ksQlwfM9stksvZ5LFIVomsr5514mig5TQYa0gKFcR9N19COE1KNynig+nIgSDEhHUw+Tc4dfR4MpgUEsVvIaYsAtOwrYJ6Oz+BtM8OFrSVXB1I3Ra3qejxCSM0tTPxqjmzBOxLaWim5JNCVGk1qSMlFIJcGECDTToNdq4nlNsuUp8rk0mDFev4GhGLj9PuVKGa/XRTomUSDwaj28WKNk69hZCxkmiuIYg5yhEhs2xaU06kSBBUy+9/2rOK1N8mWVrozRpIVruuhhllJlCk/LMT6t4hiwt7FNGGZxHA0MiQzASRmsP9rFVnVuv3cFo2DROn+Sp84/w1tf+xpmKoXo1bBLGV7//Gf5/37vtxGhhnkshYKJXdRI2RW2793E6LaRlo7XqSGKOX7ul/8hf/Tf/UvUmTSnj+fpXK8SRyFTQqF7t8GNTodpTWd+Jkt9L+Re0MNO5dgMQ1rrPcJQcu876+TsDeaKedTFDFs/uEFlaR7Fsjh78TR3v7tC03PZ2qujbm5jTJjs1/pYXoP5108StmNm5mZp17psX9rBS2t03BhQCGyDXRumy1mqrYg7X3kbzdB58niOVHGC3mxEWs2gPKqx/d27uOUc9vYmoRey8PIpmu8+QI5l0XIqi7k0QjG5+6hFypFMZh1odEe3jCJVIiREkijyB9QAbTTOhSJGV9TRyj+tpRK5kqYiZEDoKzipJBVXUSS+G+AHLp7PSAoiY0HX74wOjecFSBnTbrdREbS7fb711f/E9GyFiZk5Vu7d5VOf/DRBkMgoOp3OqMDZtk2r1Rqs022GC+lRjJCi8NyLr9Cu13jUWscwTJqtLmMTFZaXl2nWm1T3D/DdNnbGRokNBDIx+/f9AYdPYgH5fBEhBBPTMzzz3EcfIy1KGfPW177K7s4j4jCm2+6hKBqLSwvsb1dB0eg1u+gpHegNGNb2YPUPilQI/Yh4cPiFEAk5OBKoikIUJYEQiqIkPkgD7G6ISdm2jed5I27S0fX90e9HUhRidG0YLpDEXg2F05ZlEcQxURxjShXXDwcPETBs60NLDvwdndIf/ut/8YauG5RCQTmjUrQglVZw8iqmBqmsiuFoqHEAikCTOsLroasRvU4dJ5tKTMNtA8cx6XZ3UAIPQ098qE1b4z9eDhGqIJe3WXnYYjyloaoxfTdEdH38gybN3QOyKS3JhRcxjmGjaQr9dUnuyWmsTBGvucbkRAXXDeketHFyDnEYkEvpZPI5gm5Eq7pPKMGcnOGJE0s8XN1l7/41rly9TlqPiWyLTs1la3OL6v466492yOczBEGf+fmFBBTeSPRPfq/LzFSBbHmS//n/+FPaIiLO2NxaaxMKQLOwfY/SE2XG8g66JsiMlWht1/EiDekHRKrkXCHHS68/yamPnQC3h57PQTdg+oUzxG6Htt/nxm6D6Zk0hbkS4zMZzGwe0wKdCCWnsLcfEK4eoDqC3GSF8VNTRNsHHJ8rMzVTQtR6dNHIOZDOWhxbruBkbNJWkWs376NInYlTk6TKOQLFZ2G2DMU8qqHQ7BxQnpmCtODu3T00J0Wt32C8nEazVLarHr3gUJT7D3/9v0GQjGq6qoMiEYpE17TEoXAgF4HkJkZIYhHS7XbIZjNYpkMsQuJY0Ou6xCJ8jNSoDIBZbcg0RoIUgyd8Enrg9rr49QO+/+67PPv8C6CqZHMFDN1AKuA4DlJKMpnMyHI3cchMDpnjOAMvp4FrJhort28ko2GUdFmnTp1hd3cHTVVptdt0GlVOPnlxED2ljLZkUh6SFI8GQB7tThIukGT56ee4eek9yuUS2XyeXq+D74XkC3ls2+TZF15B0Rlhbkg1SZ4dfCYjga6UoKgo8jC5ZOi9fTR2yRrIRo76Xg0L0NByZvia/b6LMhhxhIjxXJ9+v/9Y3txIhqKoqApYA15Tp9NFVRM+nIhiDF3n+NyPGNv9f/4v//QNQ5FEQY+KrTNeUCjndWwb0ikFO5/CNCWaaWKaKqraH/gKp1HUgMD3yRdsIhWyuQqa34AwpDJ3gjiss7sb8GdvR7iNDufOTZAiIG/bCMNi59o+NVWytePRcFWKqkk6rxJIiSUBT+H4y88xni/z/a9/j0a3SrMvMXoHOBJy2RjLTrFVrWPqBnNPneUH799n9d4uuuGx9mgbPWiyeXBAMT/G9NwCly+v8NY7d1m9t4Kjqjx78VnSmSnKE2NUN69TGjtFv1enWq1RXBxDehG331sFQ+OLv/JZsobk3oMWBV+wVLEoTeaxI52epSZbyZ6HG8eUYhVUyUQxTWEyhXFsFloNWlt9ZK1N6sk5zIzG1793n9mcwdRMiVa7x/3dHnMzOu9d26PbDukGEdNzZYJmgHQUtpstiqkMu+/d5tinL3DtrZvcrvdoxoLzzy1RzNgYWoDSCjD3PHLHChQUSUEBkbHpVRvstTp09j2EHWA5FncftnCKOfSJNLW1Goqh0eiFqJ0AxbDx+x7dQQYbwE994ZfIpp3EFXHALA79gDAKiCNBrCQBhrEQaGqCDw05O8laPxqNA6qiDUYMlSgU6IY2OkS6YQwUVgqqZqDqKkIKTFOlvbfLN77zHfo9j16/T/WglpiyFUtoA+6N1+ujjqQV5uDAiUFBSSx2R8EGfY/JmRl2Nx+haxrFYp47K7cJgwjDSIzP6vUaZ595gWReHQLKcjSKjlTyA4zs6JiU/Pkgzvr4Kd55869pd1oUCgXCKGZ7e5uZmVk+8tJLuGEwcIBUUQd+U67nPSa8lUIQ+AmOw6CQx0MLmSNuACgK+pFk3GGhHH3GA9xO1wciXkMHRUHVdXKZLJlMhv39AzzPw7atURcVBP5oLNQ0Ddu2Bu9bjoiaJz8EU/rQ8U3XVVRDxzN0CqmIjGVgKJBRwZYxlt/GzjqgROiGh2UUiPUYTdQwpMR2DJTAJx24CA3OfvQTeHqB9t4aN67s8J1LB/zMU3BjI01344DK8UVWv3GDypkCY9MZrLyKLOUJwj7xap/yx15mRulTf/iQftdj98F17u70OHthBkVP8+Krr/LBf/4KalqQnpwhqFVZKGhUzl3k9Euf5stf/msqpQKrdxv0XZ/dtJ0Q9pQG3790j1hA0bHotgMuXb5HF50vfvELlLMKKblA320ka9ioT9xK8/W/fkhPl5yfTHPz3as4LZdPns6y0nJZ2eyR2+9x7tkJ1NUWD5o+S6bO+GKeu3cbeMBsyiFqx7z15W/z0plFnDCi/OIZ9rc3aN0PqFgq+26XmY6Gns4ypXl09gKePF7i0doB43MTxEKjlI3ZinSOT5W4tLLLhWMTHHz7HjOzkxz3I1KFHJ2VA8JMSLsTkK6YSA+sjoYbmdinxmjf3YFGwPyZ05iq4MHKKg/rbXwJV1fWyN2VeIrBmVmLpWyF976/hlHrMaGo7B65Z0zTouf6KKoGMikuoYhQJASBN9oEOY4DInGVUJRDTGKI55imidAG8oYwxElZj1lrdNo9bCd5Mru9Pqbh8Gd//H8j/Jhas0G9XieIBM1GmxMnlzh+fImd3S2mZhZIpVLkS05Cb0ilgWHnMtRpxaPriKIITdcwU1la9QambdGstwdOigGdXpdysYRu6kRSIEWIqVsjucWw8xg6EQCPbbCGY2JSmEBPZxDIkVMjQCqV4eHqBrevXqE0u4hpakiN0RgGh9Hn4TAeXT0khQ6vYSgRGY6NR7s2KSVh5KNr5qiTVJTDoimEQEcZOThEUYiqakxNTSWvoymIMAkoyGQyj72/IYY1LKLDz+Fv+/rQTun3fuufv6ErkDEdwnaPxQkTMw1OJslv0w0LXVMxNIGhp1HQku2DVgLhYWkCJ22jGNBvtclNPk3b63Plr97mnff20YKIuakUYwWVg6ZJ0G1iFFRiq4BqQeCH9OMQZTtg7iefZ/XdO0wvLdCPevj7Lna2TE4NEI5Bq3tAbXcbQsHSyTK6baKZDk7lGZrNAx7duY6IPKbzWSYWKlQPWgjNJ0JgSA1Nh8+dLXDifJ7Fk1O89pkf48yJeaQUFAol3GYXz+vihSH1jTV8KYj9iCUnz9R0CWnqTORS+BMpKtOL2GMZ9vf2OXV8Ejmew3Vddrwe7Ie0kPRtnWozwKx7fOrXPolVsvGqDby1FjgWY4tT/GBll3NTDn7kJ1IexyHqeVx70ERKDcORuGFMu6sye2wSo9dmq9Xj9EKF1LECBhItl8M7aOObMcIMEQ3YqnncVwT9R5s89eop9m/X2dhukZpzMBoh7117yOLUBLbfJVN0aLkxngA/DNGUFC23iS0s2lHEeC7HVrc3ume++Ku/gUbStQwPgaqoGKqGoeuo+uFNnnRLapLMG0fIwXZI05NRp9PpjEapxIxMHSnMTTORR8SRRLdtQuHxwbs3CT2XRq1BKpthaX6G4liZTrtH4Aeks1nGKhMjp0VNUx/LRTssToeJKoqiEYvkgM4fP07s+3heH0VVCYJkS7V4bJ5CIcf8iTNJR3dE1Dq89uFrj9wa5aGly6EyP6E5TM/O4OgqN2/dZHpmloP9PTLpDN1Ok5Nnn0qK0OCDUBRl4Lt+SHocWpscLTqHtIAjmsMjZmtRFCPjQ8Z1Qoo8FE4P//yxFBklGeVctz8Cs486WP5wZ3ioYQw4vTj5o3VKqpG8oQiVa7FGcTfmhAaOJtEzEcJTMfI6luUghY6RPoaVP8nii7/B/ff+BNn8K/rNdayiTShtvvblf0d26jj3b1WZLijMnC7S7sREgct+1yflg2kYlFIera6kfa/K2EQFe36cO3/+XZ7+/EdYu3Kdm9frnM+lKZw/jlW2+MGlexybHaPc7dK2BJ1WluIEicVK9y5KaLG6t0cubeC6PndX97CE5IkzBeyNFim9xPebbX6w0oGNAC1t4fXXKI05fPYLv8wHX/23lMoFjLE5dLeHIhQONup8/LOv4wYK9lyO7f/3HYSlYm9GVNvXmKikWf6pCwjpM1ZZ4NaVTcLYQY4b/NznztPY6/GNv1jBVwXXv/RtbqiA4vO8aXLyYy/TWH3EM2MZ3lvt8OK5InapxMHKQ5g7yav6Jrf3W4hWTMvziaKAVquFhuRMysGYmuTg0SpRp0WhOIesOOSmCqx+9w5jiyXKFZNnOzn6QY17V9ZoVgMWKw6+G3L/QZWTTpqxU5P017cJjQgNBQ2FM7kshtpDjzLsyT4zioIb+Y/dM2EYEchDe9Qh+CkUlUgeclVGYlpdGzkKiGjgbigVhAixLIt+v3+Ig6ATBOFoBa4oCkGY+AHZls0Xf/W/wnVdpJqMNqVCjkhG9NuJ9etRK9ZhofhhU7PhgUxy05LQheRHVaDI7InTBIHH9sYmY2NjeH7I3kGTMHS50Glj21nCQYGQUo7GJlXVUAax4D/MBxodfKng+w3MVJab16+RdRwera9SKBZpNWvIzXDE37IsCxTl0FHhSOqLMaAJDP/fsGMZFuDH9WsACqZpAEeSYwadUrK9g2GkefK9YMAMGPzudDxvqFFUME2LII4wFZVklD0MKUgwpw+rOn+H9k1ICMwYjw7jPnxz1We9bbLR1vC0DHrGQhAiQx9d7RL59+nv/yX3/vKnCXa+RKt/l541QbVns7rexK/rrL37kHTK5unTGUxLYjkRqZSO6XmITgfhelRrHWLZZekzr+O8forunQNKn3mZm/e2yRdSXHx1AeOjp1h/53vcv73J3//8j5MvqTgLUxhqzNL55yhMnWH5Y5/h9MVPs7T8BCs391man8NXVSrlHNIRXL3tMnZhgfS8yYtLGTLonFiaJvIOMByHi6++hukU0CKPXqPBzsoHbK6ssNv3MHMKf/GX32FhYYpw44DKJ56jqkSEeg9D9undraFLjcLCCQxNp9NLRMvPvzLPBzdqXL2+QWk8x9hHFrFfPUVEn5N9wewvvEK3XkfWI4yuyytzNhs3W7z99kPutUwerqxyeTtgzHCoFEwufPRJJiKVi7MTPD+7iJO32frBCrqrMH2AOIAwAAAgAElEQVTqDM3NKvpYkYMfbFCetVDbXVo7bWqx4PK9Jt2DiNnpMdRxBzcU2KaJ2+yz895dHtk2ZXSee2YKRSqsdVwO+iEPqm20KMLNKpj2D3Uaikw4LmGE5wdJzE8wDJyUCR8mCIiiGN8PiPwkINPzPGKS7ZwfhQzJ1kNsR0HD85LkEEVNfMAdx8HQrWTb40eJ77SMyaXTpFI2rtsjdAeHUSYs8DAM8TxvVIAOAfRDoPgoIJ089XWQCnYmy8TCMXa2t3FSOaq1Bt1Oi/pBnWxujG/91dfxgnC0pRoWT11PNk+qephl98MyGsMwME0T03Io5MvMzM0TCYnvhzRqTXzfY3p6msvvfW9QTOTgPQUjzVu32x29h6E30rAYJAVQoqoJH+uoKdzweof0AV3XsSwbYNTVJa8rMQzrsc9G1xOvJDQVTVMT/pmIEDL5XR416xu+16O2u/+lrw8d3778b/7FG96Wjxra2KrkzETI7Yc+tmHRD6DTA1fYtAKDvrSoVkNqrR672zGtPnhdlcZGle1b+4h+hFOQnHqywvR4RKfaxXclMorZ3otZa0O5kEI1VLQ4YYOG1UcsnL/A2MU5ikKyeLoME0tsfv1djs3YzHz0KabKOTzh0uoG2CmLmcoM1fUHtLs90nEXX0qs+aeQ3RZnnnkJuX2JMV/y5IzO6U88C26f+q0quTGDYtbk9t0d9gPB6RMnsNIWodskXUzTr29Rq9WYWFhi5YNVNu9H/LN/+U/5yl/8MWPjFe69cxdnq0Oq4NAN+yhNgXXKxsw7SF9y/cYqn/788/TXblNxDMp1k/JUBuXBOkrYZSlnIBRof+8h5cUi2w+3WP7CJ8hb4+xsrvITv/5jxDe2mZ20mXZVpp4cY/+DGvFuFRkGqFqAltYI9pqUz57CvbFN6exU4hXeiAhKksrSAh4GVuRgLdiEj3YxHZ3iwgQbb65TmsujdX3Ky9O0N7eZKNnEOuxsNfEthRMlg3qgoouQ5XOzSNVgr9WldcR58qf/wS8nOAwK0eCGDAfYyLAY6LqBrg9uzMGBMTUdRTIIS0yscRXUQRee/KhlWZiGNeIaBUEwEKcmGJRhGJi2iaoqGJpJ4EcYpjIg+SUYjWEYo01VNOhahluy5HKUUbEaquTjOCYWicuqiiSVybG5+TCJeTJTjE9OYFtJBzN9/CS2YaEM/xm81hBjGUpa/ks2waqq4Pb7CBGz+MRZDlZX0W2djc1N0qkMumES+V0qc4soQL/vDrR/hwkxR4uI7/ujAjjEnJICIQfAPsBR1f7huBfHEd1uFyFiFF0fmLcl3VHS3QlM0xi9l+H4pqqJW6wkGV0TZ9BDEueQxX/qQ8a3DydP/m///Rtm3ibsu0w4AY7QOTGuE9mCTlUQ9UJ6nT6xL+h3fIJ+RNAXuNUenf0+brNPazekVFKZfWqK6TkTtdXD9VzcWEERgl5XstNR2HcVMrqGrirJm0hrCD1P6ewSzSsPyZ06Rthp8eBL73Lic2dJL5+Bpk/oNVHNMSZn5nj6pZ/mYOMa23fWKRsBu5sb7DeqHDy4jeF4vPndt5gfdwj3fTprCu20yne+vclTz5fZfKvB4oUSbt3liZee5c7Ddc6dWqRUcJhbOs7O2nUKM2Xq1SrTC7OE9SaNxgHHC/O0PY+C0SfoerTrLc6/+hGo+JQvPMfe9V32VtaYni0xPZ4lCh2iFuimTvPuHi0lpPT0FHtv1jn/yWVKy7NUH24y8+wi9Svr9EyPQpShvDCHcHuoKUn54kkc26K5UWXsTJZwy6Xnq+ROFTjx8eeoP9rg9nab+7c2yOga7naDD3a70O2wtlfDUyIyaZ3J5Xm2rx8QmBGVUg7dcjCns3R6Paq+x7mLT9LuutS7PsfHU7RchXEbWh0IXZcHW210DNr+4Qj3s7/wa4NUj8MwStM0R3hDAnYOt1HaKI9MG+IPcTwyFjt6YOEw22xYkIbRQjAcWxIMS0EbyB/URE3vh4ThoeeRHBAzj5IzleFIM8R6Btc9PHQoCkGQjCjTs/NsP7xHFA1Y0WHE3t4B6XSGE0sLoBvomp4kHUuJggSRREMNv0bdw0DE6rr9x65Hipj63i7jU5NU9/YZGyvhpGzcvs/TF56l1+vipFLEsRh1d77vJ7l4ukY0iFSSHAZ+JjFLh5HqisKI55Q8MAahEWpiWWvYFvpgBAyiEAUIRQQyIWAKIREDsbUfhcmDREnGPV3VEj9uKRJwPIyIFZFsA1E+lNH9oZiSiCW+1yNVyOLQJa0ETI2VMdQO5qRCcSZNP/TpNJOUXKesksUhqgQ4lobZV9HzU8TNFmY/wm92ccMITVcxkTRdSa2bgJ2WqaLpQzdCCPsBRiD46m9/hS/+xis0V+6g9nosf/48q99doXt9C/PKAUt//wIHty/hZ01ifx+3Kzj36dfprN9m894aRtunGQQ4gclzy3na6gSXq1cZH1eQO7vYOZXvvLWDNAWLjsn4yWkC0aBSztHcvcvFj/8YV773FU489eNMLZwm7rRxhQDlj7l/fYWM6rK7s4X9wgLuRh393BhaVqWYW6T+5jtUuz4ZRefEcy9Aq0/3+i2WfuFj7Ny5wtmPfpQP3n7Ae9/aZkl1UdMlRC+kcvw461/7AHthktR6h44Mcb02O9sHLP/kR/nq73yDOVtj+R9cxAKmj7eprlXRp8bZ+OYdtjb2aaoRim7y7laNUkphzBK0OhGVySJxr8N7l1aZyNqcujBDdeeAmh1RyikE6y0yjk67B2+/eYV6J+lyrvYlMSFmrFOWsFrz8HXJdEpjo3V4z2Qy6RFjupRPzPIjOUhOjWOkNNAHBz2QMfFAmxUpSmL1axjJVgmJzqESXQwoBKploqjybzC/FUUljuLEnkPEo3CBZCVtj7LoPM8byTlUXSEIYqwj26BhsRtiS0Og2lAUNDU9krbEVhozFZMy0vTaPqZpoOsGb3/vHV59/eMITUdXD5Nm7dSh5OZomkgURcgBNypZ8ycdxu7mKnbKQQjB4onjrN5/gECyvLzMl3///+IzP/vLKEoihB2Ov2EY0ul0RoXaMAxUTR/wjxIeUSRj2vUWqqFjaQmIPwT1AXqeh23bxFKiqcZoU6crSWRSKGOG5HDdSh42oYxHNicjm5kBnylWFPzB1lWXA0qC+uF+Sh/aKf373/4f3whDgS/BCjxmMmksw0fPWKhRRLfmYwmddGqcYjaPY80ztvwxZs/+Js7iZ2lH48jaJbwwRphNnLSFkVKJo5DankI/SKxA+lFIMzJRpJ84C4gIM2MgTYuXfupZbt98gP/OFumXj2Pl0qROFKnkI4qvnCVjW9z61ib26UkePWpy5eZDnn/6eb75wRqnnz+H0u3S78ekdlUy8ykuv7lGY9/D7YQ8e3aWsy+eZmOvQ6vr0r1T5Vq1y/6Wxxd+5XPU9hssP38RxWuweuNdzMwMb/+n32Ll0lWefP45DBXWDh7x5C++Qlzfp/DcHN2ehWL18fs6V9/fI3Rdll84RfPBDiomOQt2799l4+0qM4spjHSG+SmdJz7zAm//P9+lt1knMgQTZ47RvvUQOadR/Mgyf/aH71FQdTYv3aNhCNb0iHtXD1i/fIdb9/ext5oYxRJXbjziQJV86jNnmBvXebTr40aSKctkfExQ33HBUPBihXYXNhptYk1jfbvDo+0um27IVrVHqEhkL+LMTJHCWETYiplOGxiKIBCCLpJjs1nq7T4d71D79kv/9W8OMAmLIAqJBp5HcTzcOEEQBgnBUlHRB0/uKI4HEUoRksTcTdeSNbs1GM1UTUfRdeIwHnVhh2tndRTHFEZ+wqa2nFGhGY4ziqIg4sSugwGpcDhGaYNCNuyoYCBSHXRrQ5xIVRTOLJ/l3p0VUrbN+FiFXr9Pp9VmrFTg5tUrBKHP2PgkhqE/JgcJgmTUTTZlEiT4QdJpigGQpqCSzeTZ297i0foajVqNdCqFbTlMVMaYnJjl9NnziZ93HOMNeEpHXSiH4mFVUfB9D0WBvuuiSMn777xF2jLxghDLtkfeVbquEwUh8SAQIBIRDMigUoFosMCQChi6nmxPk+RJYiEwVC3pkDQVgURTVISUGKqONuRLxTFBHHPmR92+RWhIRaDpMUIxCPQIXwWr79NDYCla0v6JLp0uaFEfY28Dq7RL++510vE2HirFWY10cQG/0UZ2Y9r1Nm5gIIOQQFHQREjKLBB2A0JVYqsmahO0KZO0F6K8s87Cb/wYqgpxswtWBmHlUAMXr95DPe1w+YNVxiYzPLtc4MbNWzx1YZ5s7gT31UdcvtIlEiEnLnUpzOY4Y1rkz1VQMjrbYZ96o82PPzGGX0jjVNucmkzTvbdKpTSH33HZWV+nsbrGrerv0G3GuL0OE4tn+auv/jmbew2q/+ZrvPYrn2Zv+yEfvHcXoav4wiOUKj//QhE9UyR/ssL3/+jbTPUDqlFIVSgcbD3E3cuy9NpzvPtbf0I1o1MydPavbXLqnzxPabFCvVnj2395i8xYiNANtLzOZGDRr3Z45WKefHaBjqLz/ju3CGu7vPiFZ3lw6TYpEXLzQQNkhKrAejdgJptlcikBLxu9HkKxeHa5SBCk2a8FRFqEoWicsVWUik6rJZBxn519jRPHc2xvttEcB78vmCoJpqZKlJ0MW4310T2T8IqixwBORTlM21BV0DQdXU+6lQiBIiS6ohBxiI04ppXYnkQRUXyYd69KRmGXR6UPR0HaYUc0BLUZ6LYg4VElRSIadVKj+z0MUVQVy7YTR01FQQ6K2rCQjMzlfJ8nzj2JJgJiIVjfWKcyWaHRaFCtVun0ely8eBEvOuRf/TCBMhbR6DWPukRKGeEHASfOnqe684h6TXB8+QzFYhHDMDho1JGyl3Q0g2JiGAbNZhPLtonCcGRrMuzKDMPAcRyEhGeevYiqG9y8fg1r2QSp/Q3t2jDlRDEe9y8ffi+lxFGNpBsCDOVwo+d5A0qCngiHVTmkDyRuEebf4dH9odYlT1csmUk7SN9nuWyQywiyRkQmo1LKWtiGwLQN4jAiVRlHs2xUcwHLnqJVu0NGW0EEGkbawS45PKydwGm/hWJZ2Jkst69UkX7IQUdws+ZghAG6KkFTSVVMTrz2MutfeouzP/cS99YeYt5vUa37rJV1dnZCtE6bwAY9VvnUazMonsu1Oz7F2TGm1TqlY6f4xjdXaPUTBz5DKqRxWAjbPP/aC9RnXfLpCm/eWmHrapXPvTZPt91j3MrjFuDOlQavf2oBFwe/usnBfsDksXnibApdcbh1c4u000R2Q96/06K91yfWVcxQxdclIvb5/IUxFi9epO12MIWG7uQ5uLnKo3du4LsB2WyaKwhOtWPCMGD2ZJn6wgzHpkv0vBgzLXjvratoQqUvddTYp5DWUEKLG7stRAQTYwbdfkSprJOtlCktzrB7bZ/AUli795DIExixwcy5KR7c3OKVFyr4V9qkzuQQuRzVK2tEWY272wGxEiNkIqI8U4YIBUlAPpUnsFNsbG6Rty3SBmxs9GhoOs2eN7pnvvLda4nndhwTRv5j5MCEzXsYZzQsYsODfnRrNTzAYRiik3Q0AQKTgSXuAFfSdR3f9xmutYcY1PC+DsOQdrs9kI0kBetopNCwg2FQEG3bHvkNQZLa0Xc9kGLkcx3FMWEQkLYt6ntbXLp0iVwuh+/7GIZGLlek1+vR910+8eM/Sd/3RkVzWFyHhW4ozxjSEoare4lCHEd86X//n5ibn2dtbY3PfO5nuHH9Ks1mnUK2wE//0j9Gij56ZCAMBryiQ7rD/bv3mJufBUVJSJW6SSTiQ3B64HWk6Bqh55POZUd0AMMwkpFNShT9cFuoKwqhSB4ksTLI6xsW1CBEqIm76GPcqIHzQyDihJcWxfzUa0/9aNYlwd3fe+PihTEqpiR2k6wrTcaYppWI7GwNw9bQbJVY+KT0CBnsIf011HgfFIh0wWZ7mlD0yFk9zKwKqk6hWGC8olFd9XFdjW0vYsoQ3G7bhLrJ6597gft/8D2WPvsM9959SDadZ+alZ9i9dIdKV7BUUrnnAZGCpqjcf9jgkz/302QO7lOZ0AjdkIyT5u07e+hC4EiNC7HCS//oNRY/+QxaSqN2eZN454CJ+TSnzi1SSE1iLM7Tr64yNj9FtblPGCikUxlq2z1MS+f8Kz+DYzg8uHOb9l6fvO5SefIkx8cU2v2QvYaPpoXIKCKtGtzeOODhvTV6OwdMnT3F9//iCr0rqzzx86+jBSGLv/hxzPt1Yi3m2IunMM6fwDw4wMtrTC7PsPnu97i67iKlxsnxDCL0uLLRo+cKCoZGNwoIwhjPg8JsjrPnTvPBH7xFqd6i3vI4f/EYp585zt7uPuefnmLtwTbpgsPswiReo0l6HPZuNDj22hMEvTavnT/GVDnD1KTBQT1A9CIKocZ6zaXR8ZnNGDw68Gj1BQE6hiXpuofj28988VcTrlKQRDENx6zkCRsPyJDGaOQQQuAPrHOTYiAGB2u4ugbNSIzq40gQicSWOBZJ92OYZsJrGYwsQ+xKCJnksIkkqHGIQQ1HFd/zUFR1FEeUTqdH1hxHR6GkSAZoR5TzkHRNrufx1lvfBSE42NvH9VysVIpSsYhUFHo9j6nJGYRy6J456gYGB3fYJYk4cb9MgOsY1/WQYcTqw3vMTM2g6Dp2yqRWayCFZGZulne+/XWm5o8TMbAOBpAQhRFSSMrlMsrgs3ecFNER+cgQR9IGJFTLsUdjsKklwPRo9S8PU46jgTOlJhXEoKzEUQKaqwMJylG/JSFEAraPiLIKmvrhQPeHFiW9t/JGLmOQVuuEk9OEtRqBD34/QosluqGjaYIwTjYdPgJFNfAjF8II3Zlgc0/DEh7ZtE3Y3yGdy2Ppgm6nQW5yitnzL3P1nSt0e4I/X1X4+c8/y8mXTrL5pR8gFYW4WMTfrPODS2u8e+kOJc1CjRXC6Rx7+z2kqqCYOsTw/lvX2K4bGJkU85M57u7VqHckxQmN/U5MX1fZuHSPnb++TUUKxv7ey4w/cZru5j1MJ8c3/+J9JtINwi589RsP+dhzCxzs7eCHOlauyNjENGeffY7f/eOvkFNt1Ov3ePNulWvvb3BissjSk5OY/RAZwmtP5JjJWPRrkr1A59iMhW3azCylSJ0p0G7tUv7oCdKpFJffv8azP/syxXMLrP/Rd8hcPM5X//RdPnj3FvfWO8xM5WjUFdZ29zl1rMzzn1jm3BML/P/tnVeQHul1np/+Ov55csZgBjln7mKxiXGZltSKy7BFUZREmQpVtmi7fKGyZRddZdMu21VWqWRbpqWSZDFruSLFsFym5RKbsCCARcYAGEzCREz6Y+fv80X//Q+2LO4FL1S8wLkBUJj4dffpc97zvu858/oUw7uGmJufRxeSwycOcuH0LUp1FxUKgkaFqekK1dkF4qpG71Abb3lwDyOj/fi315i+voyMfXzHoubq3LdjBzdev0Ghx+HlMwv4kaSqg2uEZPNFyl6dTD3mjtSIpCJUEqH0NwhyP/TxTxFFIY5jt5ZIpi2LbTstyxGlwG9ylJRKqCHpQ3P3aqaUNWwYRiIyjWNsyyZWTVtYPyAIA1QT74hj2QSo9RZIHYbJ9K1Wq2PbNnGcaMJM0yQKQ2Qsabhuc6Ik0TUdz/eaRMeEf6PrOlEYN72sm6RDDWzTxjCTHWcqVkxN3aZ/sB/LtOjr6ebO6jK5QgnX81sM6cQxQRKFEbS8sZOkJIRoLeSUUUQ+m6Far5JvK+FWPfoHBrFti3rNhTjm1As/ZM/BgwR+cn66oaNQCF1QbzSaSW9DcpK2fOn5pt7cSil0AKmo1Wr4vo/ve+i6aCX9tOqJVUyMTD5e0xD6xoRSV6Df1Z4ZutWcgkaknk6xhN2jv2BSWpv+3meRIZaMaCz7iK5N1BfnsC0dO6OjpERooGINL/AQKJSMEJqJMjMIvcbkjRrlsk+uZDK87yi18gKahIwjCOsRurHCgQ98jJMvvE5cDZm+vEBweZasGTDyqfdw4X9/jxdqLls0wUAxz4TVYHnV4+p6g1jGaFKBTLYvRIbBieO93Lq0Qt1vMKhshoKYbN3n0SN9TM026DHh4KffSdeBbUjfg6DO8o0JnLYiB9/1EMFKQNtAJ52NCNPsoPvwTtzbSwztG0K5FlemXqdH1WnvK9A2OMT4hQnqts7E2AK9KwG26RPf9KloGnO+z5aOPCNDJpoZIyvrvPK9BWpGhevX1slVXMrzi3S05Xn++WtMnr/B9sMjnH7pKrUauNIg0hRPfPgBjj7Sz659mxka6kPVFUsvXeItWwbZenwbFy9Pcb8bEnRm8a/eJjfaRUefQXvWICjHbNlRwo8CbNfFKposLNUpn7yG05ulrJtU/Rr5rODGnQYjm3IsVZbYsXsIPZBUvZAt3R1M3ylzaG83q5Mu249swVteBi2mK7JYijZ4Sk/95u+RyTiYhg1NF0jPS9o7TUu8oF3XJfAjNLEhw9B07Q0M5ITcqLV0U0oluJNpWcgmVyblM6V4VfKm1xKyoiFQzWopUban6n/9Lk5PE+dpyk3S5KM1NVqJeZxPGG6soU7G72HC39E0iqU2VlfK5AsZBgYGiOKQ1bV1irkc5fI6lmWRz+ZB0qoyEuO0ZBTf8rlWSWskmz7joe/jBj4ZJ4ttaLz04ktYlsnpV1+lUWswOTHB8OgWpqZm8GvrhH6dwc3b0XWthdelrp93G/UnbZvJ8vJycg66jmWYaEDcBKdTK5OUuhHHMYaub/C69IS3pBlGi7eUUg3QtGbllPimSRnTcOstNrlGwsfaOfLz7XDfNCnNnv7yZ41CN9mOLYR3bjI1sUToB+hKImwDKycxCw6lrEm2mMUpZRJkPqNjCoGdtamuS+p1yZ25KkOj7Yw8+BEas6fIZAtkihYiMFCVOa5WYrp37cD2fYzaOqV3HaJU7GB9eoUjx7ey5cQIQ48dYdApkr+zRqeyqIc+dV21sr+Nzux0g96qx2wl4vXFOr33b+XsdJUzY8tsxmTEMul/7H48TUOrV7EyRdZv1BE3q0y+eJaBoyOsT08SrUqKD+1EBetYMoT2fsa/9gJXfnID98o8t6/M8dKlCapCw5RZpGVjZ10GB3IsKMWCb7B3fxs3llyWyhHFuZj4ts+Bj4zwyisLVFyNiVWXW3Or3Jrz2dMP9RmXV+arNIKYNkvSCCWGaXDuZ7c4sHWAUGSZ+eYrdG4boq1gEg8PU1+uYFyYYt+/+lVG+nopFS3aegWBdMERFHsd2rpzZInRswbDW4Zwuroo7RuGhmB9YpGethydW3dRaCwysxSj3wy4c/023brFvncdQLgBE3M+5kKdve/fR2d3FlVdpa+/AxEqZmpu6575jd/9DLputB7a1GZDKdVyORS6hm1bKGhNvGBDo6WaFIJUimKaBsZdH6MpiJutn2ySHGFDvqJp4FgOicRBbyUrrbkmKK0aoijGdd3WCD2tHhqNBkptbPUwTaNVHSXJUJDN5lr8pq7uLm7dHGNxYZ5CvkSpWGS9XCZWMaHv097RjdJItrQoiabRGgSkuItuGknVr4vEtK5ZxZTXyoxdvYiKYuYXF3jv+95HW2cn23fuJJPNMjg4yMHDB/jxj77P2NnTbD14DNs0WnSGFHdrNDxM0wBdIKOYfD7fwuNS/lc6CU0Tfgpqp9ckPduWZEQmU8y0EttIfInPWsIXowWQJ5NMhVRvPn1706RU04581pSS+QtfZX5ulivnV1GGRFMKywJhgaULYgOCeoTRbhI3JEqLMHMChYllR6yvekTKYPziPCMDeTQ9wjIFVr4HIUwsp8ThBz7It//iW3Q1XPJbh2hzHMo3L5LvLGJpEmtklHhyimyY4bvnx5iXksjRMCVUgxil66DDiUjR/nCO4S5B96ogzjTYsjnDzHzAnAyYMgUvn3ydMy9d4vrpcZaev8L+9x8i+8AWBjuL6H1dVG/P496sMjQ8Au0Wq6fmyXRD754hVqdXeS3SWI1D4rzJr3xgM4fec5yVazd468Pbmb1aZbImsYrr9DntrPk+Q/0Glyp1yoaNOdegUg0IMhIzCpFCpy2OyLdnwPI50JWltzPDaG8bqws16rrAkYrOAZul2dv0b8vit7UTzQZMXLtKUF3BbgdtssH0c69j7RphpTzP0M49qNBDrUcIXRJHPt2jPaxcuEVxeADDybF+boqG0aCro8DFa+MEZga5usa246Ns39VHo6SYHl9k/tI629o1om6dxTOLFLsF56+sUpmv0zssGF/aIE8++Wu/3WIVp9OYdNVPavCfvFVVC2tKWdm5XG5jbOz6KKmIghAJhE3TsLg5fo6bo2tIHvBCoZBwbywTLwywHBtdS4ia9XoDTeMNSyzTRAkJ/SBxmgzvYiyrJh5lNRnJCVtZygQ/SUfuaXt6c+wq9UqNO0tLdHa0s7C0iGEYjI5u5ebYFQLXI9vWlujbmhSAdCp395qkhD2e+IWHUYhm6PiBR3d7kXyxSKGQo1AoMD9/m57eLlZWVnAbdSIPbkze5NxLLzJ2/lU6+jcjYo1qrZqA3JbRNNxLrpMSTUqEabUSyt1C3bunp3cLarVUw6gnIuuUnHn39VZSI6FcSOKoKWchsS6RKgYl2D3685PSm2rf5s/8IZXxb1AtrwGCQn+BIBLEkUgc7dDRDY1szkZkbfBDrJzCNLLEfoxyPfKGRhwJ0GOEMBkbH8ccfTdGtgPlLxKJNZRaR01/g9KwTWjY5CrrVNyYC0s61t59NNwC2twaY194lVe+9TJVy8A3JO9/uJ+REZOSbhMHcOLRvXQ9sQtL24QSGnv/2VsZ3trN3LzBllCnM5+lbzRLu2NiKsnBSKddeliDHRjK4tYPXyNTyGM7HVTXPCZ+cpZ8+zD+2ioTX7/F+quLHPyth/jU77yDzZHggYN9DO18gLWbl1grh7zwxSvEbTY7B02cVZNMrNGVE3RldGSUYbvjMVH3WNUjYtqkVzQAABo4SURBVN9iV2SxVzfZNphFhoK5CixIiRZJYumjd+hkcjHv+cAomw4dI+dmWXquQv25cdaljsoauA2JaOskzrrYW/P0bxlkpHiI8vgcxUIWrWhgtedpy+URZhuQ5fTZy7j41CcXeMfvfZTxyTX6dvVjLsQ8+La92DnB9akFnMDmyO4BqlbAphM72Hv/flYyERfP3yJvZBjYP8j4oveGeyZ9WAM/cZqUMchYoKGDSKZolmW1JnC6YVDI5hKgOdWdSYVuJqJOqW3wjJJ2MKkANN3EsC0s0yCXy+KFQasl62xrJ/LD1s+Tz+dbdhxpEqpWa822Mml3oih9CDXM5oOafnziJmC1iJiWZbe4WIaewBiGMCmVisRxxOrqKl69QU9nFxfPnSObzeGFHlM3rhLLYKPSaALLhmFgW07LEUFKSRSHTaJmnWymyOVLl1iam+G1l1/klVde4vbUNM985StcPn+Bv3v669y6dYvurgEGBvpYml+no7eLTL5AZ3cXbR3t2PaG31F6jYhl62zTxNNoNJIhRdPTKsHjQnzfb00NNamQQXiXe6XYqISUaH39OEqSnSYUUkXNyvaNBnf/ULwpJeDzT7arrj2byNkO46/cYLFgcetSjU5D4OR9Su0OmZzCMQ1ybRa6aWOoCE1YZLIQNRqYSuf8BRc3jPCEhaFHfOTXfwUKAbIySSmbJaSNKF5hNXuC//GHz7BaqrG1YRPOVKlELn7J5GrNINBihFRoIiKrdDrbcjzyzl1cn5xjfQX6Sw3yMkTYJjdmA6am6nzwbQcJWKf36DY8IYhmFrn93es4nQZWbzc3T03RvamIN1Hhwc9+hLP/9WssBzaXHY+3ug57P/MYme4CFz/3FU4HEWGbjXcnJlNwMByBFQWsBhLLU9QzEiO2QAswNYMdrmJok851KZh2Je56A1PoxJYJbsBgr0FPocDirRq7jvbQu7sdR2lM/HCcOAtSk2Rlnu/fmqcnn+fAvk4GN/eCpSNKAyyvrHF7ZoI2zeLy9DKDm0uImSVywiQ7uBXH8pnFpHfFJHu4i6f/8puMbOrjvkcOUr2zjhjsxq5WGPvqz9j8/p3I+iqqZ4SLX3+Rw48/yJXzl+juLVDo7GVhdZ47ryyw66kTCOHwky/8AKOQxfJ8Llc2EtOXn30FlEDoTY8fYbbGzJmck6ysVhHIph7LFAnH5S7ANX0rQ1MioSDwfKQOpmm13uK2baE1bUVimp8XJe2cYRjoTYqA3myH0kokTTQpZpLSEILAbyXNNGFIKclmc9Rq1dakLgj81tjc95Jx/9f/5q8YGh7i9vxt3JpLHMc8+uijLC4uMjM9SV9fH21tbbT3DOAU2jCbtARDb7pBGhs8H78p25GxolItszg/xavffY4gdmnr6mxapgQMbt7CwvIKKjSYmbjOE0/9Oo++4+0YWYe1pSUKHV2JB5KeLN+M40QsnGJ3sdIQyP+PhhHHMXGy8aD1b6CVQO+2J1Gp82UMLViJDQpBgvspgjhIpp3CBE3y5DuO/lxKwJsmpT/7WLfKdpSYm1liccrjRTdPl1thpGTS1W3i5ASOpchkbHRL0d6bQ4UBumNgSFBuRM6GV8+5hJFAGQIvCLBUiY/+64/hrIxh5DV816M0sJv6/BiXazleP7lGcbidlbOTlKsxy5evU3hgCy+8tEAkq7wlk6N9s4N702dtKMfs1DIlL6LoFLkU+Rwe7UBdWqR7tIuzS3WWnQArdtict9lciRn8tVHsvlGi2gLjf/4znPtGMRs2Ey+fZ7boUBdmi+7vBzUGA501J0sjCunuzLN/e5bXb6zh+yGejHjnuw6zee9Wxq7doqe9gKkr2jt7aXiKv/2/30kU7LU6+Z4uHjqQobNtkIat+MF3r3BYz2F0mziFmKpbQQUO0/MrDPYUaR/u5bnnp3j0wT4QBleuLnLkUAc9o5sI1QCrz77GpVsLdO826S5oPHfFY1cxg+sJHn7iEIUOh4WLC9hb+5n53nnCxTIHnnofz/3F0xz4rUcYe2WCgX4DK5NhZfY2kwshff2d9PUJRNcIa7cmOfXqJIFUaLaJdGPefmCUmgi5fGEGT48ZGejk1WsbNm9f+PaLmIadJByjadNKskIJkvXN6Vg6mcjob2AipxhIKsdIH4i0ukgTxd18JNGc2DV8H9mkIyQ7CZueQk0QPFX/t3CcZkKq1+vkcrlk227gtzg8ppk8vDKKiVXycxiGQa1WI25qzZRKbHUvvPYSY2PXicOQ/sEB6s0ttQf37yKXy3Ht2nW2bN/GysoKg5tHcIpd6AqsjIOhb7g/pmzsBCROKpml+QVO/ehZgjBmbW2dbDbLP/03/45KvUZbodA8H1r8q9THSikNIZqkT6G3thRrWmLIlp5lEEQtN4Y3kEnvasPTP1Ome5KgrI1rZ2gYmkGtUkY2/ajsbKZVhWkyubZ2NrFc+fCbJKU3xZR+/NX/9tnZmQaTMx7X1x3OL/h0ZW00O6RoGcSBRz5rolSMYWvotkBDQ1canudjZxI90sxcAyUEgYxRmoaw6+zeM0B+aDt66KJnHLy1dTQnh92+mzNTM7z+zGnK1+Y5t7jMEpJCR47ZpXXMyKTgRnhBRGk0hze+zvbhIu2DNhcWquRKGa6t1Vl3DFZqgjUnIMYklDXWRQwjbVhL0Lm9F6RFaWeBeHWJjqLg+VmXSCg0R/K2h4c49PABrp4fx9V0tuwuIc2YmeV1JicrjOzK8bFPf5zjx3YRz48jlaJnoJ/Ka6fQ/BCUh9XRQ5cWcOjYDo6+bR+bt47wja+f4ur4ElMzizTqiv7I40bZw4gk56YbdMz5DO0qUezI89yPJ9i2s4P5BY+BTV0MbrXp27af8vNzaNUYPe+z7+MPUvBMymWTw/cP0zg7xZGndjB3s87MF87SdWIIrxLSMdqH2tnL3z39Q1ZMwfahHi5ev83MxDr9bXDyzDK+oTE7X2Hs+gKy3sDVIhYXXNoKJhnHodiuODu1RmWxzFDocOidh6icn2Em2Ji+ffJ3/gAhkpJeFyamqSM0A93QsGyzVaGkqvU04bRCJT7QGiKxDEBDquStHEuZLENVGw6VSilklEgXwjCESIKho6RANtniaTuRtlxpm5jiOblcrvU1EzZ6UoUBLWA+SaRmi/vkuR4mGk42x/rCDAu3p+no6iaTsVhcmGfr6AirywssLy5QLOYYGOil7vpcu3qDuclpdhzciVTpYsnEUkToGkIXBEGI42TQdQMUZPJFtu3agx6HBGaG3/j9ZI1VLpNF00TL9iRNmoblEPgehhAoXUNKDc3QkhZaaURxSBDEKDQ0UuHyRmuXJsioKTeJo0SEa9k2wjQwhNkE6yVKJctAjeZmFNtxcLKFxN9Jk8g4maAaTU1jYtQn2bt18BdbRtmZsdWaF+E4BtKPkXrMoTad7Z02XXlFLguFdoeMA6alkclbqDgmn9WJYoUFxG7I9UmJq3R0LcaPNYg8Dt93hF0PHyAbzRCU1/FjDUPorE+t8rmnVzl4f5HC1sPc+O/fYdyPWHVidnRZDA3mKNcjgtjg0rTLId9lPDKYN3UsJMdG21gjYHq8wi6ZgSBgrNvikXcepC3XYOn2OidPlXm8r8DQU0eoLZZRjqL802murJW5Wfax3ApPfOAQpS6bzKb78OavcuXCBKdPz3MgFAg7ZNv+UXo+cJzxH7+A7kYEl9epr/lEhqLnUCfr8z7WHotOkcG0HOyj9/Gn//4vGdg+zNrsOoGEnAPHdg/x6uU1vKhKzjYSgBOdrtjDDH0GZRbfibipC7RQY19/gaDLwluBvg7BwOEe1k/V2PyeY4RGzMU/fp5D//wxRHkFx9Bp1Oa5uRjw7DfOE2Qs8kojNgQylAhTIJUgmzE42O2Qy1p859IsHzo4xPLKOh07dvKdH5zm7Y+OoHTBxQvrLKzUGdUE+957jOdfOMtqvUylsXHPfOXZ11o3ta7rSJWskBaakXghaVrrjR5FyWrvlt2qmVQwqRFautRQKZUspjB1TN1sESBb/JpUgqIZBJGPaOI1hpZKImSTjPlGAD6tlBzHadmgQKKYV3HiAKBbJpae+mwbrc+J45iG79JouDz/9BcJYkmj7lPIZ8jlcrh+wOKdZXq7O8jnMhQKBW7euEXd9cjk8hiGTnd3NwePP0JHRwembb3BlSBo2tqmE7SoyQUTht46v5T/dXf1l569UsmSzTTxa5pG2FTSCr1pJYJO1BTLJkJkgyBIBLl3g9xKKdbW1lpJPZ8v4jWFy9x1ljR/HsPYuNa62LD+1YRKXjqa5ENvP/JzK6U3FaHUghDH1ECG6EqhSUEsbEIFjSAkn7PQ4kTZrRs6sQzIZbKEUUTWcdBUiAxCbFsjChUhoIfgORanTl1m9HCeOK5jBCaBv47tCP7kr29xvhZhXnM54CxQCwJi20bzQ4ZEG9R0/JuL6AXFfYYBx4qMvu6TX/PwMibFuTK737uVrX0mo8ceI9thkfvPX+SFb5ziyY/uZW5xlUjW+f5czKcXI8Kogb5eQ4zm2b66QKOQ5U4Y8PSzNyma8MijK/QN7WSt7tKfVZz4/SfQ8g7x7G1mnn6BsNwAP2b/v/04Y3/2bQYeP0pZRNS/c4ZN+/dy7Y9/wuYPbsU/d4ZPPHmMwvbtfPuZU4iowfFDHYxPeDRwMfRkuyuBZLMj2BRYjH7kCKXduwiX6+y6coHJS2U6hgZQ/ZLK+Aw35uoUeovYx7ZQmZ0gDH268llqtRpqbYX/87djqFzIpm6Dx961m5++NEmsS/KOyZ59fWTaPSqrkpszddr3jtA/PMBvH93DnfO32POxx7nx3Pd4YF+ebM5gfkpyZ9VFGBq1KES1webBPA9u2cYXnznTumcUCXcslhJkYn/RagniDWlJAoCDZRuttiq17bCtDFIl7UXgR+hGAqAmHkjJmzmMEnFtytZOTOSSezH1TUq2pUhCGZOxLDKOReQHSHRkFLS+Z7r7LVIJJmWaJsIWTcBX4QYeuWwGqSSuG2AIHa/hEgYe7toSYSTRhI7vuezatonZxSXqjQBDaARBRF3zaLg+mUwuSTIhVIKAHmHT3dvTwmlSCoRSqrmaKcF2DMNqrn/aqDA3krFGHIetxKBUItMSUgF6SxsXRLIl7YGmIFiFmI5NLCUONsoQ2LbZ1KglSU+PNeJY0dXVheu65PP5BJcyDLTWeihF4PuYpo2up222npBDjXiDd4YglsEbeFP/ULxppZQ1LCX1ZIXx5lKOTBQhsxZbzJhN3YKsIyhmJbmSTsYxyORNdAtMpSFMhSUElaU6elbn0jWF0gyk5hHHCY7Q3Vvkk//ha5x/+o/4+6dfo9AlaC9m+OmEojSt6Ntb4DsX53FjDSejETZCtqs83aMK3dV4ab7KsGGTr/hcKMQUI0lEjmO2wLAFfft3YPZ5fOWrk3QMmXR1F5mdrHD0LSVOvrBIyXDYWzIYedsJhJhjbbJGcc8OsnqVr/zNOWJDIw4jiGG0t8Dube30nbif+rXLeIsz3D65yn3/8VNoC7c59yfPkT9QZPjxd3Dmfz1L6dg2ro9NcPxEN6HUqa8so2LJlvsfRHV2U51f4+Tps4yfXebhnk66e2xmMyWGt3Yz++WX2bK7F31vO2M/m+DiNY/H3jZIqVBievYm+ZxDaeQAV185yciurayvr3Pz+gpTSwFPPLGVbGmE6voy3/7uGfac2MzZH03w7r0drOahPYRr8xW2DfZw7vVlPGGxt1FFDOhQs2l/9yFOvXyG3uE+ehZXifs2Qz7PyZdPJ9dVD+ltLzJzx0PWGmwtlnh1bbV1z3ztuZ+9wfqjhR/JdDoWYeh2stI5BqmilrF9WgGkVVL6to0jhdDB9zYsXtO3fVotpZiR0HUscwNcT1nI6ZjbsiwavoehbXhIJ/vgkgSgWlO41CgtSFqcZsLQNI1quUoYBTRcl5Pf+zZoFqvzs+y77yjj16/imA7rlSpRFAIalp1BCUV3qYRpmnT19dE3OMrA8DDZfLK4IP3dkYr1epV8Jt/CNTWNJvfr7qS04ZZ5t++UEALJBkaHlvo2bVjSKmKEam7YERqmsZEkkrYtbHGP4jiGMEZpqZWLQBjpKiUNdRcdIGi2fnfLWFJrmaSyTTAuKSVPvfe+XwxT+sGzn/9st4oZOTyINuEyuLtIw6+TixXFrJFsMRHJIZl6sr/LNkQCcMYS5YYYuobSBEtLCk0HIUyUlnD03foqrz/7JcbHV+jqMejpL0DV5S9OrrBm6FydrSX2CoaOKXUaESwqSWEdzkUSpQyqQlHLZdE1nVzBYnBTnlcrihnP4/z8CjdvNIjtgD3deYqWoG9zD8WSRWefw9WJCrcaAQuv36QyvcyeD7+VYHYRX/PoDqoc/+B+tu+wyDfgwd95EiMTsXB5HH9shsXrHp1vP0SwdAFryw5mT9+iY4vDzcs+P11cpbs7phKEbBrswM4VKRpF5s9VsXt1NC9GLxaxixncs1M89i8/jFHMM/XN03jnJlG2RnlqlpXZKlsGuth+wKR+p8rJF8eYXVE89JEPE1guPSPbkB4898OLLAURpukwu7DKa6fGmJ5d5QP/5FGMm7fZdXwT3o9u88DHH6dnzz7Wnh9Hy6zRXhSseCF2n0XP/k0MPPgWcvksVMu89d0PMPbyGJbjoVZm6e3SWVhzuH9/N9NzHiqQbOrTqUrFnfoGpvTRT/4uvu8TBEELtAbQdZMwkDgZG10YTRJec4uJTMbycSRRzWpA0xJNVRjKpqWHhpOx7hrNZ5LVS1Fir5FQDJLxPCTgdhTHqCBJVOn3S97EJNVEqu2Kk+ShKVrqethwoDSEkWjsRIJ3mZYFaJRKbXR2DnBp7Bqf/sxnINSYn5ig6vqYVgZhaGzdupN6vUEYRGia4M7yKseOn2B0x3ayzb1zaatkmjaGaWI7GYSmYTZJkJB4oRsi/T0SgiIkjOm7t5NIKUFLnkFIWlpFcq6aJpJEL5PnT2hN3pVIuEUKCUo02eZac9MMoOn4QSKJ8T0fvZlApZTNfX7Jx5uGgWk5yXVQqatmIv3xGx66SvApTWns3zn0i1mXZISLM1pEc10yewpUllysUOJpOo3Ax9BthAa6ULieIies5K2jCUxbR1M6yICsZqArRagEmlIoLCQR/fkCoiNLWHEp9JSwY0WpzSYnIkp+RBZYRkfGkliL+OT7RjAHeqgv17j2zRtYekTVU3QakoXQ4AOP7+TcmTmMRh1hCHTNJNQrEGosqpAPve8h6usBfryGtuDxB3/0OJW1eX76p+e5E2q88J++QuBL7I4iTtklXLnAj+94HMJC+T7VF26y40Pv5uypL7Ft7zbmZ6+S2zdAMV/EdEDNOVybO8/O7h7O/GSKUk+JL31rgi0dHgeKHWTdMm0jDxLJDOdffI1rZ1ZoRBHPfe7rjJXLbO3LEsx7rPTCw21djHz6ONe+f42FKR/3So2t/SXMLocf/vkXyTmK+959P1GteUMrjfvfNsjBPbu5c/Mql6cD1GqDLBqFvkG2fO5+librXHr+79n+2P04AwIjUyD745P88MIdLs/e4viuOzjKIMBn8fYK9WrE1ckyD+/dz63pRYJoihcveTx2fJAzZxbI1wV9gw5Xlqqte6ZcLrfesJ1d7ckNS4LDZDI2MpZomsQPIzQl0HSQxMg4RiMBxxNQO8GVMhmrtZ1DCEEQJkLe9P8heUhTTKjVGugalm4hDUkcg0A1AfbkYco2fZQAdMfCUBtTvdR0P5WmJHSBDYwnFfkqpejo7eQTn/x1oiii1N3J0be+g/OvvEzgOMSNGnuOHOXWrUkiIXjy45+gXG3QN9CP1dIAbmBimqaIkfiBh2Mm2291MzkjRyZOjklratzlLS6aSUBrSWgiJYmbm0liGWIZiQOl0jSiMMK2MkRxgIqb075QYpjJKB8gClXzXBMvJU0kux59t45p6i2b3WQzid+smCSWYxNHAZpu4vvJGcYqxhYGyjTB0BAYLYeEnxdv2r49dHSbGuxxcGSd2esrrDdCTMtBC0O2lSKKOUEhq1PoFJhoZLM6jmPiZARCGUgVkCto4ErOXotpBMlu8RiFrkxGekxy/Q5xzUcKnfa8hZGx+a3/coUPPr4b72dTlO8EtO/o5uJUg6qI6LIMnvzEMWIR8fdPX2FgtcH2o4NUhtu5PV1l39GdlJcX+c4zr1Ds6kV4Nd7x6DCLcy62pnPoyBbqfh3p22RMg+XxBbr3bya8MIlzZIjJL7/KbNFibr2KqyX6n/sqkH/rNoaGS2hOF+c//ww1y+DAuzcTlYa59qXn2bWliyMf/xhuMWJFxIR1nfDUWbL376VUsPjRv/hr2h4p4vQM05dVtI8+yJn/+S163jPKzZ+dJnsHxmoBDz46RH6wi/pPx8k99S7c6ytgBOh1jdy2Apc+/1NKu9u4cWaOzdvbWTlXZcWImLQFkRUy0tHBA/e148U6bTmTv3r6Ch9+5z7uvB5S3FzmxkKFwycOYbYJJl68wvRyjZlVHy/S2bnD4fKVOiVMdmwrcXtqnQWhc2xnkVPnVylqsG9rHk9TBI0IdbtMaaTIt69ttG9/+czJhE3dHD9z10LGROOWyBwgacHS+0/GNLEjA0VIHKk3sK43GMXNkTZxYpEhk3YkeZg2NpXoup48eEqlhk7Jm19t+BpFUYRuNb9HLFuTwaTy2Pg78AYAPvk3b6AzpD9fyjHKZDIoTSfwPMr1CuurZSLPZXhkM5lMptlKJjhRGunv63leS/qS/i4pPSD53joJiG22Pj+tTEzTBiSRbMpFxMaZKbmxRSWV5uiahpRRwjE0DNA2zjnwI4QwUATIUDU3l2hIEmGvQBKrZHBRq1Rw7CxBmHDWwiBGmBbqLioFCILAQ9d1fvNXH/rFeEr34l7ci3vxjx1vDoPfi3txL+7FP3LcS0r34l7ci1+quJeU7sW9uBe/VHEvKd2Le3EvfqniXlK6F/fiXvxSxb2kdC/uxb34pYr/B2alnyYW91p9AAAAAElFTkSuQmCC\n",
+      "text/plain": [
+       "<Figure size 360x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "img1 = PILImage.create(files[1])\n",
+    "s1 = SiameseImage(img, img1, False)\n",
+    "s1.show();"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The important thing with `Transform`s we saw before is that they dispatch over tuples or their subclasses. That's precisely why we chose to subclass tuple in this instance: this way we can apply any transform that work on images to our `SiameseImage` and it will be applied on each image in the tuple:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 360x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "s2 = Resize(224)(s1)\n",
+    "s2.show();"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here the resize transform is applied to each of the two images, but not the boolean flag. Even if we have a custom type, we can thus benefit form all the data augmentation transforms inside the library.\n",
+    "\n",
+    "We are now ready to build the `Transform` that we will use to get our data ready for a Siamese model. First, we will need a function to determine the class of all our images:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def label_func(fname):\n",
+    "    return re.match(r'^(.*)_\\d+.jpg$', fname.name).groups()[0]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Then here is our main transform. For each image, il will, with a probability of 0.5, draw an image from the same class and return a `SiameseImage` with a true label, or draw an image from another class and a return a `SiameseImage` with a false label. This is all done in the private `_draw` function. There is one difference between the training and validation set, which is why the transform needs to be initialized with the splits: on the training set, we will make that random pick each time we read an image, whereas on the validation set, we make this random pick once and for all at initialization. This way, we get more varied samples during training, but always the same validation set."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class SiameseTransform(Transform):\n",
+    "    def __init__(self, files, label_func, splits):\n",
+    "        self.labels = files.map(label_func).unique()\n",
+    "        self.lbl2files = {l: L(f for f in files if label_func(f) == l) for l in self.labels}\n",
+    "        self.label_func = label_func\n",
+    "        self.valid = {f: self._draw(f) for f in files[splits[1]]}\n",
+    "        \n",
+    "    def encodes(self, f):\n",
+    "        f2,t = self.valid.get(f, self._draw(f))\n",
+    "        img1,img2 = PILImage.create(f),PILImage.create(f2)\n",
+    "        return SiameseImage(img1, img2, t)\n",
+    "    \n",
+    "    def _draw(self, f):\n",
+    "        same = random.random() < 0.5\n",
+    "        cls = self.label_func(f)\n",
+    "        if not same: cls = random.choice(L(l for l in self.labels if l != cls)) \n",
+    "        return random.choice(self.lbl2files[cls]),same"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can then create our main transform:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 360x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "splits = RandomSplitter()(files)\n",
+    "tfm = SiameseTransform(files, label_func, splits)\n",
+    "tfm(files[0]).show();"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In the middle level API for data collection, we have two objects that can help us apply transforms on a set of items, `TfmdLists` and `Datasets`. If you remember what we have just seen, one applies a `Pipeline` of transforms and the other applies several `Pipeline` of transforms in parallel, to build tuples. Here, our main transform already builds the tuples, so we use `TfmdLists`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAASUAAADICAYAAACuyvefAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOy9ebBt+VXf91m/YQ/nnDu++XX365bUrZZakyVrYIhASGAzxsSB4BSJjR1SZZdTFOUEO7ErVaSSSuIYKhMGHFcIRSAgx0KOTWwGM0hCQlJkkITUQlJLPXe/fuO994x7/4aVP3773Htft3gCCtyvXfdb9eree86+5/3OPfv33Wt913etLarKCU5wghPcKTAv9gJOcIITnOA4TkjpBCc4wR2FE1I6wQlOcEfhhJROcIIT3FE4IaUTnOAEdxROSOkEJzjBHYUTUjrBCU5wR+GElE7wAojI7Ni/LCLLYz9/94u9vhP8mw05MU+e4HYQkceA71XVf3mbY5yqxn99qzrBv8k4iZRO8IeGiPw3IvJuEflZEZkC/4GI/LSI/OCxY75+ILT1z3eLyHtF5KqIPCoif/1FWPoJXgI4IaUT/FHx7wD/F7AFvPt2B4qIBX4B+P+Au4BvAH5ARN71J73IE7z0cEJKJ/ij4jdV9Z+palbV5Zc59iuATVX9b1W1V9VHgP8d+At/8ss8wUsN7sVewAlesnjyD3HsvcAlEdk79pgFfuOPdUUn+DcCJ6R0gj8qnl8hmQOjYz+fP/b9k8DnVfXVf+KrOsFLHifp2wn+uPBx4FtEZEdELgDfd+y53wJ6EflPRaQRESsirxORP/3iLPUEdzJOSOkEf1z4SeAzwOPALwI/t35isAt8M/BW4DHgGvAPgM1/3Ys8wZ2PE5/SCU5wgjsKJ5HSCU5wgjsKJ6R0ghOc4I7CCSmd4AQnuKNwQkonOMEJ7iickNIJTnCCOwq3NU/+1//F96tPK+rYo6s95osDtE8c9JGuTyyXC/oUmS2XrKRmZaHyhklMSLdARXCuJjab9FT42mNNhYiSEboUcShRM6IZUbAClTOMqprKWVpf0dQV1jmwhpH1qDV476m8x3tL4yy2bfHe45zBWo9Yj3MO6x3WCsZ6rLVY61AD1pa3bozBiAMjiAgqFkNGxaKqqMkYteVYIJGQrOScy/Navu/mU27uXWdvOceEhDGGRpSD5QE3nn2Oa1efImVh1IzpjLIAej+irj33nDrLXWfuYms8JhuDiZmD2ZTnLl/nuSvP8tQzl7n+3BUODg6oqgpVRWJGbaKiZhl7FMNstWJvGZnGjtCXqqpqAgzrKquqIlLeK1lRKZ+1iBw+t/66Pn6N44+vkXMmxqMBAa957f2kpOAcfd/jRfG2YhmWkAU3aljuT9ne3gajpJARMVBZlosDtkebJI18xZvehK8aJjtnsMZgXUWfFZczSCAnSzuqyQmqqkJEWK1WqFpijCTteeyxJ/jFn/s5upT5j77vr9HYlmXoCUQQC31P3/eICL3z6HKOk5Y+LOj7Fe/9+feSy4f+koQzlqiGb/rWb+Ff/MI/KQ/eIcV2VZXf77nbktK4aXFZYJVJMmYclKWDzTqx6AO+cfR9ZJUjpu9JOAiJUe3Y2tjGG6GPif0cSJpYRWi8w3qLNY4RHieGYAx9v0BCIOVIzsPJniFoxqGA0ohBjWCtxVmLWoNYgzW+EAuAcahYxBx7z2LLRlz/HYyQouKcIxtDVsFgsChIRkXQPGzA7MiqWKeQv/RGNcghQTm1zCUwEQsq+AzEjMHgTHmNnBLJlfPDGAdqQBWLQRSiGf4PySRVSJmcM0LZcMYYshgEIeSe2hrmIdBpIguIAmRKH6w9XO+aUA6JxygCqMoLSOv4z8YYVFMhj+fh+SQVY/n9sOowviKGGdaA9zWV8yCGdnebHKHXHpsatFZiLjs/5IQTy6c/8zBf9daHED9C6cAqohbjhBgCzhs0C8YIfVhRVRVVVeG9J4TEbNFz8f4HaM+fhiv7bFUtfRYQT03F0sxxImAsfbdi0QeMQG1yudA1m9z/mlfx8jzhF3/vX0G+Q3bzHxJv/oq38dTVp7C2IsUI5Bd7SV8Wt03f3GhE3W5gxxt415B2dhlt71JvnGFna4NTk202JyNO1RWNM9iUaL1jY9JwbmfEy8/scPfuBmOX2LCOxfKAxXJKCAFjlGYyZmNrh3O7Zzl9+jzt1hbG1eAFaSrGp7fZ3N6kampAMLreyAZrLTjwWTDGEIgYBJMVtYpKRkQoWxdEhWSURMZmizOGmAMSC+kZIGMGgjDDRhQgY+0R6RgFK6b8X6I4KyAZMUo2Qs6ZVlwhQaNUzlN7S2UAFWLKJFNIxoiiKYIpr9+LkjG4DKLlo9GoRFEUgwqkDCEEnCREDREliUEi+GhxyhAJ2cM1Q3ks53wLiais3+MRjhMXw9/6S+H5x62Rc6bvOxJKih11M0FxxFXPYrEk0rFaBQ6mN/GmxviIicI4w2a7VaKslJkuIgcHEQ0rXFWRlhGbC5EZBM2elBJIxjlHHC4o1lq6bklbT9g2lm//89/OxrjhH/zY/4QfWZq2EG2TKwKWtq6o65qJM2y4Gt96vHPEEDB7M/7u//m/Yfh9L+p3NDQnHvm9z/L5T34aZzzG2hd7SX8g3D5S2tiCGJCVZ2Ucdc5466hDh/Qeuin1Qoldw4rMXhfwTY2rG5p2TNVadmrHvF8xzYmDaHhuPuV0VSEyYqsZsbNzClN5QtfT75zmynNPMB7VnD+7y5ndXSrrWM4XTG/ss1ouMQJZBNVEjoLxFZ0RHCUaysZisZhhEx+mZWQYnkkkQMrGN0IeTmgzkAmU6MEYQVXIOSHiynEAAkoaIowEauhjHiKpTNJIRQ0i9DGQUiLGSI4R0zhcspAD2ghiHTlnkEKoxkDISso95LLpbIYUe9CEEwOmIolCThiEmEOJrhykvI6QelQz69RtnbLdYpbNa8JaR1P5lq/ldTJIBv2DndDOe3wFiiGJIajSVjVtY0jRsexWTEYtdsNhe0VcRdJMUKFpGq5f3Sc5R1PXzBYd7fwaVXUeYy2ddoxsg0gCIl02aDY0xmK0RJL70wMwlhh7EjXbO+eYbG/RPLcgaU82DucTq5QY1cJitkDE4sRgrJC7KdaOsHbEy97+Jt7wlje9FIKLL4kE7O/fRHNkPNolxPmLvaQ/EG4bKbWjmnbc4EYNrt1gvLlLM9lisrXFeGNCO5rQVA1N1dK2LbWzqDPUzmMMbNWeU23DPae32KkMp2vLqU2PsZmmqWk2WiaTEZu1Z9RUbDY1d7/s5bz83ks8+MADvPr+V/KKl72ce++9l+2LZ/BNhWTF5IhJisHRGSWTig60JomskPXwCrfelHbIwEoEZbHWogNplfROh8jBHP4eHKU7VkpEpSkc+x1TIpCsxNyBsYSB3IpeZUu0psOackJJrCST14+ZclUThZxjeQ/i6LOSVIiaUclYKQQTU180LSnkabMZ1qN44zGkw2jpOBkdrnmtKQ0QOuBIFzp+jKqCOp4fEf1+nQCaMxotGhMOocKQYqSPNRih8jX7ix6NG+wv9+noiBrp+x4NHTt1gxeDRfjdT/0e1iTIQlLwTgihIyZhvpjiK0vOmZTK+02aMQY2JltY64mScd7wrd/9XXQWxpTXHo0mJRLOFlc5rGnZMharmd7UHBx09LKimi5xQ1T+/Pf/0oCBHAHP/a95I8b5F3tBfyDclpSaekTlaurxmMnmDhsbm4zaMe1oQt022LqhaWrGbcOo8oydI8aeVe5BMt4YfFuuZC5nGpsYqWCthxzZbFqc1HjvS0pkDHedOcfFC2c5f/oMk80xk80NNre32N0cM9qYII0QotIP6ZlVg9WSZgRJJQ3LcUhXiggNkEkl9dMjklmneGpKXqQiGAMiiiFjRREpRCUihxdMYwYiokQiDKK3qCeh2EFINUlIIZY0I8WygaKSMvhYtJGUS1rlBr3GGIOVoi15WzZClSgEKiWq8bYqaWYuontCqMUOm1nxrqLo+PmQPIxZi955+HqUemV1lIhqregajsRx88II67ZIiDVsNxt467FG6bqO2E/JZKwzbE88aX4FE6FB8DJiVLWE5YosGWMcwQRMVdN1HdPrjwMRSxG0TW3xkwlJI84X0ghZSSngrCWslgQiYxPQPtNN51jx/MgP/1265Yq6raiswRlP62qkjkztEvQp9r74z7n22C+ie1f57BNfYHNrQkrp901j72xkxBje/Lav5vxdZ4l9eLEX9AfCbdO3qmpI1iIrgXbYrAISBPIEUkBjSzNqqbuexvWkEJAIYRWZVzMmzpD6rmgNMZPFYp2j9g3z5YLJxi7WVWzsTFBrGE8829sT2o0tmqYFNYScOHNqE9PNuKkdqxiYzzMqPd5mnLaElKgG3cQYQy4qTKkw6SCSDhtNc8YYweYakxSMwKH2VHQdM2zSPEQYJYUTsirK8JhCMhEsxBiJkklZERxIJptMpoi4ISdSypi1zmMLUazPdR2IjbSmvoymQozZKqLgjGBQVDNGhYQjknEGMor3jipGQgSHkKREGAAlQ7RDxHSU0q3xfAJ6vtj9pbAWwY8j9gnrhWWVWc0T4gXTWpx4UsyoKSldXY04vXOaaVxiIog1qE6oXSJpJKlQtTWPPPxF7n/gAliD5B7JmRhyoU2rxNhRV2MEwVcNmkr6fGpzl8V8Ci5z7vxFJpfuxl+5ytmdc4TUs7Wxy3w+ZZ4rmvkn6PZ/D5PhQtsyu+ut5L5DkuPS3fdw4/qn/xCkfGch58zHP/Zhcl4xrhvm3erwonqn4vZCd2VLRaMd4euG2jc4W2N9DXVDXTdUzYSqbqm8Z+QMDUroVywWC/Zmc/b35kxXC5Yp0cdAHiIlEUG7joO9myyT0seAhghhifcWzBClmEzTtozbMVvjmp3tCRttg3glZ6WPQswJExJxHRXlEi0VHJXu4/CYUYNkQ5ZMBpJmxBapu8jdedCdjqIJZwxmeE7yUYpIMpAyRgSbQVCM5lJxS4kcAin0pBDpYyipVyo6kygoRfROUqIhsyaFYfWi6w9KyAg5QVIBa0g542yJ4twQJTljMDKQyvAat5b6daik3Rr9rLWkW04OY16Qtjw/BXz+Zl1OPFQeFWjbEeN2RFDoQsRYwYunMhbrHeTE1avPgsRhrSsUT7ZFy5stFjx3c0qsxzgjKBbnPI01GIG9m89h1JJSIlvFiiHa8nmnpHQxYDWzDJFv/Y7vRFcrfvxHf4g+rHDOUTU1LR1V/Aynx4ZL58dw5s2cPnOe7dPn8C6UKNoId/Aevi3KeZBovGU1BMJ3MiHBlyMl4zHOUtc1VdPg2xrftvh2jG9q8A1V1VD5MRZLY6A1YPpAXM6Z7U+5fLDPtf0l02UgZE8fi7aDCjHDarFkOV8wmx3QzW5i81Dd0kQfOky/xDuHc5ZmMqEyQtuOaZsxWZWUEiGEkgJhCYO+QFCSFr0h5wy3XP0LGRVdJh+lc4OmpMd+NnDoRTr6ekyr0vI6af28cEgKOWdyVpREjooGJShkFWBILXMqaWDKxFzWmuNR1ewo/Rw0smG9OWeMk4FgFTWFmMQWoV8zXzLaOa6ZHa+gFd3E3kJczyccWTNk1kPR//nH1JKprSVFi0piGSJVb6hsRQqRpe0IIbBaLZn3mYvnLhHTEmcNxlgwcxweJ7BlDTlHLn/xWbobl7FS0sxOE32I7G7fRVMV7cxFIeUAQfCTmhhjSXW9xxtPyoaVg1NtA6lcFFvfUk3fz5ntbTbO3suV9Bba0xc5tXWOqqp42xteR1pOed1DD9JULw095vko53FiFSy7F+/6kheaOw23JSXjLFbModhnraWuS2nRuApbj7BNQ/YeFYsDbOjRrqNfdvRdZt4l9paJvVmg6xWNZSOBwbliaOxjIHQRcX7wsijEDp86NK/Q2OGcw7mKerRJ1XiWfaDHkFWJGaJmUio5c84lpTp+RShVsuJ3SlrK9cWHNOgqa1IpPwwfXCbmfMvGXtsMcs7DHy8DJSXMKDYpkaJJCZBSQmMhz6QZoxCHuxGtN3bOkUIVghiDdUcnjTHmiPgGwrVDHLU+So0cmiDX6au19tACcKuwnQfS0Vve15EQXh6ztlTe1joUh4WEQfw/9ELdeoKPFVLfscpDhTLEgRiE8XiMtY66rhmP25J+9QHtI11KWHFYmbBaLpA+MpsdMGlqHn/0MWZEsil/saCZ2nliTly7fnPQfCBrKSoUq0DPxtYpjM1459gaj1j0AQ1Kc3qbqA5fTdncULIbc3l+L2Z0ltQry9l1RpMx2UjJEqwh9t3hbrnTN/XzkXPmwn2voTmzSdl3d/bA2duS0qHA5yyuqnHNmGq0webp80xOncdPttB6A2Mr1DpCiOSkdKtAl2C2ikxXPX0AMS24mnE7obLQ1g2uHiHWEboVdtzQti1t7Wm8QzSRbQXOY9XgXI2tG6rRiL1VoAsQjpfchygjpSHaSQmX86ERE4ar+hBBkPIgiuchIrJlo+WyAXPO5EFjsYMFYf0astaZKBqUJi2l+JiJKPUg1cWUkCEayhoRLXJ7zoN2dUh4BkQKseVMSnH4v4SYivtdrCl+qSy3kGMiFT0plvUZKyiFnF+oGa11pWOVt4F8y/drkiop0ZHgvY6uhr/j2gWuLzx9+hgJqaetPZotbbOJrwxqOkLo8H0iJ6UPGec8bVvTp0wm08WOlAOaMquQWWEICn60SQwdTrviMZKS/nnvqeqGqjZoKqRujMGE4qbw5igyTnnBX/5r/wliIh/+jV9gqZF09VFGzRlW6SFUKnwzYmtnm/FGw+72DufP3YNTQVzivgcvIc+LPl9KOHt2l5tPP4tgCeHOFrxvS0oxZ1xVMxpNaEYjxhubjEYjvPcY1+CqFutHmKoFqUjiSDFiVLBiwAmTdsTmZML2qW22J2PqtqL2Tbmap0Dfrwgh0a869vs5yzin627iqhFu1GBdQyKx6jr29mdcvjnn2l5HypBXq6LV9IF+GelSRDRBjiQdUgwjiA4ko1r8SvGIYKysW0UiSUtkUKKgjGjCDGS3hijltXM+JCdkSNGsIENquDZtqiopx4FMCrm5wTW1jj5g6GSQEvEYM6RR60jEJFyGhGDNYXB3WEm0moky+IpUkFtc3Ee2hnWE9KWu9GLWvqt1tHTUmlIsDWA48iqV6uWXSN9sjbE1VZ9QgagzNEdW84RVA86QQ4CU2Nu7TogdTTvGq2G6f42Ueqp2TDMesbt7hhgji7Dg859/kmvXryAiVNYRQiAQqapRuXg6i3VK3/dkBGct827KaLyBMQZvNkiu4sZ0yezadarasjxY8PTqZSzdfeycuUTUSFU1YGpm0yVPPnGFt3/Fm2llTFN7BtXhJWml/MTH3s/yuWucPn/3i72UL4vbklIIkdBHMJZ2PGY0GmF9VVK6yoN1rGJi1iWiOlzVINIQrcXXjonzeFcz3hyx2Y7xOGoRsinGxtz3aIjk2NOtZoR+SVO1TCZnqUdbeFtjfEUSwzwHDhZLnttbcO3mjOlyyWKxYLFYMJ/PWXVLuvmKrutKX1hKpKFHjAQmCQxkkklDG8tQEYyppGzH9pemdTq3FoDNoY1gbREAYIhcNBc/EZhDHSrlTE7lyi9rkshKTIpExQxmSx3S0LVGdUgGg69KVSAnbCrrMQpOZTA5AFrStcO0UMyRQn7sIz4inEJWR6J3iWp+3563wYR6XEf6/VKYlA3OtogF42rS0BqyPdlAxWHUYV1LRmnHE3IwTGrH9eee5tTueZqqpW7AjT1d39Plno3xJsvFgspAXVUA2Npj1BNS4uDgoBQmNOK9xWgsxO1qViokk+nJbG+d5ru/7z/jrrt2uHe0gb/nbUy2Xstoq6Wtd5k0LdVozOZ4wqOPfIY3vOGtLKNlI2ReuX03r7l0hp2qYcuPwVbYl5BLQIAkwivuvb9IJHcwbptcHhzsI5rxo5qRllSmto489ugCXDUi5Mx8vmS+XEAq4bPiSjUrlyqI1+K4jXFFTC1xPscaT7KObCxBlKax1I2l2ZpQjzewdfEuAVhXoZ1lf7nkuevXmc72SF2PDz20jrhUiKuyWUkchBVNPYJVhzoHYrFOsHVD3YwwoxJuiCjiBhc2CkmRIWWTIj8RxOI1oRqH0N3iTCTmUqMTKVGY5ojNpRXGINiU6NcRWohUwEpKVc2IkgiknAlSLJ52ICVrDImy8SOKlxKZJXGoZhIZkzPZGlwWoijZg01QAwFQyZDXYnv5WvQoBVFyKl4ggOL6PqrGHRpNB02qEPK6bSUdRnYGGQj61nNGTCL0c8abW/RdR9UYNNbM+gOMjJFkMK5nNJ6w6ubY3LMIFTtnzmKsJ6YVKRZ3fZ+U2jesuhnWO1zVMtu7Qb0xIfcJJLE1HjFbJBpTFQJ3kZAjLiUqD4uojFyNkEm5IxnoOuWjn3yYVz30IJos4hzjdkR3dZ/NdswHf/X9vPlr34HScfbSRQ4+/zkuvuYCN5crzrfXCN2c33r8MsHxknF7iyROn77I57/wCUK8s9O325JSVGXR9zRdT6o7gigYj6ZI3wVmB3uEVce1a1foFwsIQxk+ZXJwLJzBiyH3gXmKLPpEH6ekrmO6mLO5uUU92aIZ1WxNPOdPn2Zza4eqbvGuBeOwrkQW1bhha2uLne0Dwnyf/b0D+rAiLC3OZEzeYqGW3Akj35LMsjTuGo8ai2s9zTgOlSqlqkeIREw0ZYNaDn1Cagq5ClAVEQrgUDjus2JNQlImmyJURwQVBSIdERczqQ8YIk0tdF7IyeAwdCmimhENOLWEIf3CQNZjhs9BY7KD61ONYlKJ0uLQVmFU0ZBKfxklehIFpJgI1kRjbSGo4s6+NeJZk/BxC8F6ukCJEAt5HY8QM1pSxecFTM45qgqmyym186SVgj2AbMg24L3BGsNiOeXmtaucu3CJKiYWYYnzK7zdJKwOqFtP7Duq0ZiceoxxvP99H+Gr3vFGJn679NRIIA2i93w5Y9y2eBxBMxZLbR2dZsZtC7MZuZqA6zh77vXc8/K7aesR0VgMSugDxm8wnd3kT3/tV7Ndj3jgwoP8359/L1/5bV/P/jNP8Vf/w29i88IZUrfi3T/x8/zMr33oqPXoDkeMmdnBPjkFjF1rhncmbktKja8wxhD7xMFyTt2vaOoxXb/g6tNP8vSjj7Jcdsznc9J8ifRztItYFWbTgIjibI8YxywKs1XmWopoNtTWkFLibNOyORpx34XzXDxzjma0ga/HJRW0hhwjdT1mMgmcPXORvOrJ8yWrgxvMZwfYlPBWSBlmyzlRHNHVZZMJONtAFprtLXbOFL3FWiH5CiNFIxFJ5GgQGZIdPTJhpiFdOg5jDDkNPWbripgoQYuI7fpUrAZ9B33EIYUcEWLO5JwIApIDKS8wugFQSGMgwazr7vw1IQ6JnpFhZkLxWalkvFh08D2ZdeOy3qofpVRK5Gscb6FZV/XK/7f+HRnI6IXjTG6HZC0aMt7XjBX2NTB2FcuxYHIC7VgsM5ONlursXQiJPme2JmOmiznBXmFn8xzL0FGPxsR+TlVPUFXa2rBcRZYHN6nbUwTjSKmnqTxd6AjG4iRR4cha0vKRr+m6ANKjaqlMw6te82pUA9Ebtv0YV0duXlPe+sY386FP/jb333Mvn/nNj3J2d4uveftbePbyY7zsoUtMNjewGlGUb/pL38TPfPBD0H35TXanYLWcghGs3YG0h9giU9xpuC0pmVzSgKeuPEPrK3bbMWY8Y3n9GnuXn2XvxnUOuhVXn34a23UQA3XKxNCVoCmUkR/ZOmZ9Zq5wM65KubkZMbXK6dO77LYXOL29wcbGJpN2UoR0YzBiUGux3tM2G0wmS3a3JxxsTTioa4KN1F2k6qC/MWc9qmOWAgbFmwrUYWJmdX6XHFbsxnNYb3Btj5rmUMMRU6psxQ1+rEte16lK0WE0FUd3SVMTanuymuJ2T0pOkS6uqLD0YUHq90kholboVdEcWYRITBmpPUQlZ4EMXi29zbjE4K8qkZOUOmCZOWUcqqlU2ZKlSQrGEE0q1oicSwuOYfBgWXKOg/Naj5FTSeFe0KybFeMg5VsJqOhPR3+XI5J6/kkdiaKMIhyYhFpPDIZeE621HNy4xmhjt1TLvBZ3ts1gG7RqqX3m5sGC8cjTh56UI9IXvehg5KCPqEayiVjV4m0SwYvDaiYbRw6hpJ8oLoN1Hltt0i+nRW7oe+rasWMr2o0G5wyju8csQua+zVPce/EiF7/j29i0Ne//pZ/izPlzWJ2TV4b9xYKqNniJ5L7iJcVKgLMtb/+33sZv/Pq/QO88PgK+LCkl+gD7TzzDXmW52VQ0VY3JiRsHM27s7/HE5x4m3bxBn8oArlVSYlcaLHOfAMU4R/ClOdWGFbZuWMzntI3Dpp7K29LEK6XMvNYp8kCKljJHqZIKL5bGKk1TURkLOdGveqTrYBpZpMhy0WMMVH0ZGmdrT5xPsSiNE9y4zPexE8h1RWVahvFtpFQIxw7iMxQfUFnPUeWlVPMSRi2aEykpSXIRu3MmKcQ+EAOE3KFiIUUCiZxgmSI+QkhaFmmgtxmTlAgDMXPo3FYMmHVVzSGpVAp7W4QNqwa79iipJaf+ljRMde1ZsgMBHVXXjkOkRJ3HfUvlsOMklY+1qtyq9jZ5k2Q6Agtc9tjeERulNkpOiZ2zF5mMxiyXC7AjcprjvWd/0eGNYNUzHlVl4J+FnD1tZVmmyEY0fOTjn+btX/laJpMtFslgrSH1PbauCHGF2AbvHJqgV0PlLK6p2d44w+Xnely0VHVDbR2nd05x9fpNHnz1q7jwwMv45ff8Y+pUcdelSxwcHDDaPU3aOMfTN55k0zmMcWxtj+lTzyl/iledE37v8h9qv73omIwbbl6/DCKUpqU7L427vaa07Jgul6y6A2SWiNpzNUT61YLp/gHTq5dJB3uEri/l5H6FTYr2PSkqXZ+w1lBZGKlnpj0TY+j7Oc432LBClnNWszmr/Ru0bcuy3cCFjly3GLFkLWM/QrditTygm8/pVj2x64dG1x6jEV1FwqpjtVyyDBGbUtF5VKlTjTjDbO8GflyjI0dGaMIm9ahFRh2u3UC8w1gwYg7LzHCr9lQdn7sAACAASURBVJJTOnR6r71KOQb6nAavkZD6nl4NXehZxp6ojiSJkDM95fEomZziILAPl6yUSzNchq7ryIP/CiijVbAYieQI0SUEg0uBZEDEICZBKGQlBhgI/oiEwBhFhBKdwVB9O0rrMloi1GOEJSah2Q5a1PM8Tvq8k9omTA50nSlGW79gOg2cPbfLfB4wxrA/vcl4NKLLgcbWxNzR+jLKLydluZoxmWyg2QOZLirOCaGyjLTiyuU5bX0dNzlHhaH3FU4MrhmVCDZaXF1IpPItrXNoCGy2W4Ss5JCYjMZcuPce7nnZfezuTOimU77nr/xlvFd+5B/+LP/xX/wLPPxbv4GamzCNTCewaafceOI52t0tnp09xw/853+L7/3+/wp1FuILW3fuROzt3eDhg5uDLHDnERJ8GVK6uneFq88+iyfhqwZrHN66MrtntSR4h4xGxOkM7QJYSx+Xg+sYEMGh2JRIJiMo3nsIitcI3Yz53nWuX36Cp2rDarWi7+ZMNnbwzQbGFr1DQ89qOWV69QpXLj/HwZXnmO3dIHYriD1mGQirnmW3YBUDOUWMGnoDlozEBTqNhJswH3ukEvpuRbNxQLu1xWRzg0YN7WiEqetjHpx0aApaR0ulQ8SQ1yJyHGwDeTA/krBUxNix6BPLkOm6FV1QQoyoOKwqWROVRrwRYl9c1jU1K5njgPm849krz7EzOc3j8XH6ZMh5yenTp5ktOpbLiBWIVnAGKiOQzFEryOBaLw3Jx0exDM3FwyypdSq3np8koodTFg4JSA1HOtNQlkQHW8GtaZ4xHX2oEbtHFwN7i8C5cxeYL5ZYY8hpRW3LNAmDI8QlrmkhJGKOuMqx6hMxrHB+hFeLryxIzWK2j7EVn/viF7hwcZeJcWVSgFqyKsFADpHGWowxtJMtKq80zQixFaHrCSkUA+bmBGLmdW9+TUmvheF9Gc6MJ1hxXLl5hbA3QytleuUKq/05VTti78Y+2xcM29ubvOUrX8XHPvI5sinTSl8KKKf0kRn2TsNtSena5z4HziBVRWUUbx1GIZjSga5NxTIHZFKzIKIhUllbThQDlSaSNVS2GAwbJxinqPWIKD4rbv8GsyfgSr9kceVpDp44xWh3g6ptaKsWVSV0PfP9PQ7299i7cY2D69dJN/aoQ08fMl3fkWNgSUCNgi/ayrYv4zxMjvSmQ6bX0GcDaXUTZqdoNnYYz3ZI8SyCxVuH2AorCWctOQ9mOeVo2gCU8Ro5Fe+Hs0Of1aBBGQemI5oyrjXESB9Lr5sRwVeGYBuaZWKnrulj4vTYcWmkXLjkWeyNeO973s0HfudRLt19F7/+xMe578wWyxvPUhk4u92y2NsjZ0M2yqRyWMnURnHiWaTi8E4U75SoHE62POp1K+OCj0yhpYq2TsfERNASpdziyWIddQ0/ZCHLrSf2tavXOXt6h8WiYjQyVKc3WK6mGIXx+DTdao6aikU4oLGA88TYE2OHqxuWKeBGI/quw+qKxjjUZPquHyp7FWIbNjd3uLl3ha3tUxgLQklfcYKvHG3T0voKMWV0zO7WiEv33sUXPvcIewcHXH7qaS7snjps/7GmuNan0yWve+gVxNzxhd/5LJ959DHS/CrWGy5duo+Lr3qAUxfO8czDv8384CbtTPi2P/VaPvLw57gcw6Ex946FNeycuYfGj3j66c/ekc25tyWl6fUn8cYjo000NLimxRtLZYRYW5KzOAviM5UvozyssSxiwvcQJ244qaG3xXlsjIVc2iFaL5Ai5sZVDhZTlk3FfDTCjye4yiBUqE1oCMTVnMViRVoEuq7D9IGqV3pVeu0JNtJ4cJSmVyNCtkXjcZWQDVTGkOcLVjmRZ3Om9WXC+bsObyxQTya4UYOIO3SESwYx6y634kq2lMf6FJFQdC893NTlKt1j0GGsrkjGJ0MQ8K5lUhtW8wNePR7zjrc9xKvf+Tqmj3yKiy8/w2+/7/286w338/a3PMRHP/FZvvNt7+SZves8e+9pPvWpL3J+a8TO6+/j4596jmm/oHFlvnflhUgqN1EQg5XSe6dmmB5J0cGO/Ee3NuSu7Q6qipF6mKx56wiT4+5w1YxKsQwcTwN8XaFmws6uQloSNZZRyiESwhTjBSMJH0oq3JuAMzVNu0lOKywWCUq7sVFmTamWJm1vEDHk1Yp2c8T73/ebvPPrvxpXVdhsULGMJi3tqCZ0PcZZQlyhdc1WVRE0M7+x4NLdd5O++AjWeqwEImWksTGOmBO+jzz0htfz93/sf+bKYo84WzAej9DU089vcuPyATc/91l2zp0h1ZY/9x3fQKDi9W96E//LT/4U+8NF7I6NmVLm2uVnePNXvp2nnnyEOzFaui0p2cXBMB1sRTZbxY/jHd4a/GqKiQdIf0CjPV4S2SVIMELJJg+CaR5SHkGMEHJpro2SMVmpYjnpJEfyTJlxHTNMZTTGHhqTI7m0WqjiMCxiJGVhUtdkjSxyRkVJPuMzVAa80cORI9kI1gRUArGPaL8kToWbIeLGG2xMdsmrFYRMaoBiAUVRGAT1da9XBkiKRUhaQv8cy4frVBDji/lRSqNp1I6aCcm2PLRj+Xe/+XU8272Be9/8IE/+7P9DuzzPJ3/2PTzV/Cpnv/pVvPF7/gZ7n38/X/Wur2EaMlc/8kEuvPZBDh57HKqecw8+yE//r+/l3R99nLqtcClgbKLFsjSlPQYMWRN6TPNxbq0rmUMj5JqQjmOdvpXBcMf740rIv77QyJfYemd272Ixe5ZsW7xTvN9kOZ2zVdcscyrtNgaQiqppsLln1UekFqgqbCeIzyxmS6rGA4auj0W8zoKmJatlxVYzQqJh2u2xu7GLuqoMwsvCdDlj2zU07QRfN7i64p4LF3nooQdAYXbtMs/uH3Dfy+/n+o0p509tkZNgTMKf2uKn/o8fxVSeaT/n1O4mURdsjjYZN3D6woRVdY69g+uMxxvUkxH3X7yL/d2GH/wv/wZ/6wd/iGRLweROhHOOlDKPPfGZYrK9A5d5W1LS2Y0SNXQr+rjCti3GGBY50832SLMpplvR9OWWNiqKmlhOVgspFSNgKHM0yt0nnECOtEbIknCxlG+NGqIoHoNo8R5JBs1xaL8oo05SSlgRNsc7fOr6HvfpCm89LgUsglilsmBF8KKUGbhgjSJD/xkmErJixaKrBWE5Y9l39CHQpkSVtAx2FIpxcmiQZfgQVaVEYlnJQ/OuQimxOiA5cphBVpyFgxx59AuP8aM/8C08/cyTzA722a4tH/uhn2D39Q/wyX/4HvL2Bdrzd/HM+77A/mf+NtkI1WSDdrth0xi+8E/fw2hjm+bV9/PI7z7Dy77iawgf/imWfcd246ls8Tmp6YvAP/DM8ekAa3f3UQR06zHHI6OSqupAYhyr1h07lnVz79EoXUxmMjrDYmh47lYzTk/G7IceMYkcwTtDskLXL6h9hUmDi75bEqoRm2JYZD0cGLe+jZP1I7Js4ZxjJQsOVj2VU3w74oGHXsmTjz0OGM6dOkvKkNwKicIkN4y9Q8jElPmar3sHH/jNX+N9v/mrNO0m73jXn8WLYT69wa+870PMV8IzTzyJ6eesFjeR3DGb7cOpMdce+Rw791xC55FxXdEv91nORuzubDI6dY7v/+t/hf/hR36SO3K3U0yU1gp7l6/zqgf+FL/3uX/1Yi/pBbgtKcn0ACWjzjFbOHpni/M5Jugj9D2aSgeWG8xqwYITxaQS7mcBq0IYmmF9NMMIj6PKVg6JaIofaKV5mBtksHEJYghG6bWiSR0JQ+8Urt/k/rrn07FlY3KaVX2dU3HJqAdvHMlHsgWj6/nYQpQS+ZgMNlPu6ZUHF3foyBmSJnoFZ/SWjV02rCdpLM26g6dJVMgqpek2JipnwEDjWpa+wfizvPOBhnf+7e/h137sH/GOb3wls0ev8NH3f5ati2cxH/8isdrg+vWnWd24ydOXb/IK/wDUSisGq4FrT95g6+5TSAz8ox//Bfa2tvntR65hfYUb+3IPO/XAlD4kEIvSFaFbZUgv17YAiig/VOHW4i4Mhb98lKqV7zKibhj7Mkx1EkVk7XG6tWUhSk3MM7JGnGRItlRDs6XXzLhpiTkMjvlMNpbxuC4zum1mbOFgtmRzskWfezQNt2fKkUhAfE23mlPXE37tAx/iz7z9K7Eu87sf/zSTSUPjHW405vrTT3Jp61V0y8D5B1/GI7/7MPfe/zKcMzx69TqTUcPnn/gC45VlFlZ84oMfwLsx1y8/i2uFCxfO8fnpI0x2ttgaOWot/q6Dm0sa8zj91T2euHyD0b0X6Zb7CJk5K1wtIA60/2PZoH8SSClx4cI9PHfjyou9lC+J26dvy3npiichxhBkPfhMhu77MsYVIFihyYM72NviqFWGSlUJOPIw4qMMa0yHA9061k2zkKzBDl6fCIjkkjmkjuwsB+2Yyyvlw89MubAzwbYtf/VrL/Ljv5R4spmws+g42+9TM0wh0UKMakCGkrsAWEFjKkPiUhzc2EeD3HIyt7RQlNlLQ/8bdhjqBjEFUi43EkhG6TN463B1h20c33pqk1e+66t59w//GN/1nV/L//szv8TTjy/5yrfcQzaZZ2/u88ZveCtXf/EpXvHt38YrFnMe+/DHef03vpObn32SuDfj8Weu8sTHH+bUZJs/981vpb54lg9/7Gn+3j/+IF985oCve8vrGZsOGxq8z+R0gGi5qYHmdROxDmK2QcytzRGq6XD4l5FcPjNdTxaApJEyKteyDq8O5zHJrVWcxllWyaHzBTrawGsqz1YOG1ZkEmBJfWQ0Lq597QLeKNhNFotI0zTE4a4sXb/E1w7ra3zMLHTFqK2ZzwOTdoSvRty48ji7Z+7n7ov3cOXGTcIicvepc1x58lHufeh19LPI2/7sn6GPPbWz3HvvPVx+4lOk+R5XFiv+6c/9DKOmpW0XbO2MyCEQ6xUXJ6cYSU8OMxarGZvn7ua+8y2LVeDCa1/DwfRJctcxlzk3r1zDLg545ouXERNf4JS4c1A+q8VqycH0AGv9cLOKOyeyuz0pmXw0ZXAYrA9y6OMR4wans2ByphelwZZZzIBFyJogl6u0QcimaEhaDhimQoIFohFMzEUQzhDtMJ4jlYpREGV7tcKbiq/9ugc4WE75lU9f5+/83MP8nX/75fzKbz1FOH2a6bVApQucGPJw590cj1KTlNaj2UxJCTMkLbc2Opy9lBJYix1aPqCI5zGVmxOUv0TGDL1mOSlWy2xsITFNmQ/8y/fx7/1338XB5cf5hne9lU//s/dhqXnFg5Eb12fc/dC9vPEvfQdP/M7DfOMP/k1udh2nRw1Xr0755Z/4ea498Sxma4M3vOIVPPDaB3ndv/9tfOGjn+DRR67yyctPs0odb3vtQ4xQGiZ0LhLyC4fclxSrXETyYTn/OONa4GiqpgwO96M5S+tUb7ibLUctLMfv+QngMmz4hsVmR5OFmS3jh8k9thoReoevV7RjWyZsrgIp94zamk5XiPMlxZBAloART0qRXhOmltI72AWsq7BG+dCHPszXvP2tqDM8+fQz1JWQ/Tbbl85y9t5XcveFczz+xNPMuzOMt7ZYt88IDqsWFwJ92seTISyhNvSrFePGorsjanXETji1M2bZLzjYnzE+fRer1Q3AsX16k37/Gmn6DLEPfP4Lz92RrRvPx42bN4CAkYpywUkvaK5+sXD7GwdQqlaaINsyI1o0EzViEWyMpbQsGUsZ8J+GgT8ul3G0KlKEZmVoFjVH04SGuyeXzQISFR28MD1AKgPOO++5vHmR3ihvuneDrzp/ml/4yMd48Pw2//33vIZnrsJqbnjnGy+RguOfx453P9XyXaM9rNSk3CHelqpcSKgIMSsJQwyJoJBCX0rTIYEPVM4XwqFMykwS6GMRzjVFkpS7jmQ1xJzKzRfV4E1kdrDgA7/+y/z9v/nniXsdn/qlD7G9vIyOdvncx7/IXduZv/g/fi9f/MgVnv3EI/z6ez7I5O5LfPFXH+afPPIY1ocSvbQVdFOu7l1he+L46R/8Ya4/c5UHXv8qnnvkGfYXkU898hQP3XeBS2cdsvBY5PDOseX26OuZTaVFxWhGsxkuMGvxukS8ZTaUoAgM0VH5oP5/9t472rLrrvP87H3SzeHdl1/VqxxUSSpVKUtOsmwcMMYYY2ibZJaxyeCZZg093WMDphm6Gxim8dDYGIzBgO3GNk6yJdmyci6pck4vh5vvPfnsPX+c+6pKBkTD6m6L1fz+0NK6r1TrLd19fue3f98kBuEK+oqm0BiIOrV88QPY93uYGZMksFmI2tQK1dQDPXEIiLDMQVPJSpT0sC2DWFsEYXqVS9OPTZI4IJvPEHkGsYqwbYkRGCQlB4cYZcVkTIGTtRGGz8WTT2PqgOvveiPVao2sU+KBP/kvvPZtP4STy9NabTNaLqYvQKE5efYCvcjF0oIoSHA9n0qtkn6/IqHbWKVaKRKuzFDM5lHaJel5TEyO4ylFoTqEH/ToLK4ysW4EETXpNVbZVC7zpOUQRy9z+YmMQJkgZcrrfhkJdF/ao5sEQysMQyIShalTs35bX4WSNWowzSgyQg4YxYNU14GtjxBcUd1LkYpKAaQ5eCDEmmcPaKEx1qyKZCq/cKKIyeYlNjfm6LxwinvvPcTTlwUNPyYMBLsPTPDKGwr8f587zGJnjlIuoGx7fEZMEhAgDIcoThvS2oAghZGmjAhBECeEyiBkMEkoTRJFxK6P5wV4boegH6HimDiOCeOBUVscDTy1k4FGLkKQ4b57v8E7bruOvop44VvPkc0KDrztzXzqgQv81G/+JG/+0e/jzNefRsY+llNj85aNfO1jD7KwvMTmjVvYu2MHW9ZPcP2ePezcfSM6CnE6K9y4a4o3v/p6yvk8pVwZW6XdfNP0RHrlMhKC1PdkcA29SmdIUbY4nfrkQPjLmqZNp28HvRbPvZYblxIkpZV+JkVy1XY3Tq1QVPLiIxQlKQWgUMhTrY1giasvHUcMQkQTsJIcJlnApIQc2C7bSA05YSKkhdf3iZKQOExIhCQ2BSKIMDImOlRYhmR4aBgdavqLF3EXF/mL3/k1VLfNwnKT73/v+2i2+kxNjuNFLqfOzoBQzFx+nr7fJ2ObOMrAIMJwFKajkKZB1jIxEk2UaBIjwMxaFHIO1Q0b8VouZuySyxRSPehEjX4QEco8luWwd98GxD8HEqWCanUEmcmTDHIMXy710ma9UmAMECZz4Ipoy4GCXYgUptdpiocefK7lYN8AKVKVaCwj5bU4Ys38DMTgM0ivTleQoME/TXQKw9tpCoMnM9RKeTZMOCQk3GwZPPT0DK9/tM6rpy7x1o0uH/rXr+e3PvYVvv+e27Dzqxxbga+GG/juzhy2TCeBSGpMpQl1Gu6YaFLTfp0+PKEfESUeQaJQUTJwx01QpknONDFFTDZjE4eSTC6bppFIg4iQREsuzs5g2JI77thNZ66BViETm2ssrzS4ZdwmK2IOzfb5wt+c5nvuUeyZrLDgekhb0wokRdVHV9dzx0++F0lC/9hhdM5G43PyG89QKbgUdcJnnjxFIOCe/TuJogiRRGgtcKO0kSjNYJEnEFeM6dYg/XS5nbK3FYaUaPRgj7TG8L7GEG6wY1LXvMPWaB7fznOxHYkpTCJCVD9kxfeo5oawHEUUxmSyBkLmQcSQgJ3J4Sc+KoopZHP0+i7tJMSQCTo2yOZMIiODAGLVxzQzaByGjAy7rtvM5i3TBD0Xv5RDZA22hiPc97lPMHd+HvGBD/P80ceoTI2y6DahM8fRpxRauRg6otXp0270mR6vknEsCoUCRAlIC1GtQCzwkyFimaHeDhizIamOgBAkbp0oSFB9DyyLglPkYmuBB549QpS8fJfc11a/38RwaiTSAfXymexeGn3TpKgV6aLYUSmbO90hpSOQoSERpAiX1pgDqDyRa2P+VRNEYUiSSCFMOWh2wJoHEKRAkGkgI0EsY0xlEoUxwfAYbqZGw1AcWeqxY3Qdd2+S/PL+bfzm3i1MGjEj7/gTfrPyHP/uF7+fi0cvs3/jGKfnZ7B7PR6wR3hFtIipNLYGlXHQXjC4mql0MlMJbreHH2qEU6Tr9fF8RRgHYJjYhqSQSdGdSjGgmM9CTxAlcRqGiSBjGzz52Av8n2+9A728wOHDh3H6HY4dWuWH3/923nT0S0z85TfYPD3Fa3Y6HDq+zNeenidu+OzavYkt1QKb7rieuWcO88xHfw9DWayuLFLIhQizyPMvHOGvz/psHJngFft2cbzeoOWFjJbyuHEGt98iSdIYqyvpLGvfpUitellzBEgkiGRApmQQrDkAL8TAPRMBIiZRFmlU9hoKKa9hgL/4DRui8II+SppYlo0TRZhZQafTxtAWQiqkkaDjlLYRBD6WNMg5NqFO0KZEDxJoclmBiCJyVhY/CjDNTJq6koRMTk2wZ9s05ZLDctgn60Q06st4aKxek7Gtw7zqjgPs2rqO46eO412eoZt00FJQzlQwkgQVR0yO53FyDpZIiZ9h6JIxLVQmz8r8eaSdpetqStV1rLhLFPt9nEIGcChkLM4srrJh83WszF3GyFdwlMJEEr8MSYnXlhAGURwjdDt9aX2nf6Fr6qV5Sjo1LssqjS/SacZSaRPRgFQaLdMGA6AGi2QF2IMHQyqIhCYvJPFgkoqUwlKCyEih+bRpSZShUALaGUngjHHSyHF5tUF8oU0+D5vHS9yYi3nD/holR1Bvtzn2+ceY3rWO/+st65kcynP/Vx/llgO7mLuwQM5OeVBxrsjy0HrGZmaIM4K8HxA6JkqaCOEQR33idouGncUXHq7Rx+159NyIIDYQWuJYAjujGC6VsGzN9EiFSrnEQw/ez2133obQitNHz1ErG0zvGOKv/uDj7L9+Ew8/2+bzbYfrH3iSv/o/Xss3njzNF752hDAxyfdXued1O5i52CKMDRaaHv4Dj1OYqLHuxoOc+Opnuel7vo/W8w8TRwZvffcP8t5KkYeOXuTfffJxoiRhuFImMiXtRhOclBuWbnI1CIVADvhJV77Ugdd0yvhO9/pXHyAtru6Z0g/WlqDpxJX+PdfKVl58nNeM+iv5Ml7SpWxV8Lsdck6OOEmI44QoSihXiiRxkDpNKkGoIIgUFgInn8XtB1iGgbDMdH8nJWGoyDk2Q7kiN9ywFcMw6PfSFFwRK/LlCp2VWRLhYsU+H/65H2XHXbcR9voknkcmk8M2HFTYwLYU1XIB0zRxbI2OIhwMfOXTi2Msw2ZiaoKFJR9USBj6+Ks9zGqJsN+hOmLj2GVEmJ71Sm2CfH6Sg6+M+fqROb59gny5ldYJAoGKepi2hVI2+mVCYxAvBQV+eIfQQgmUAKHSJbWHwmSwI1KaRKSIi9YabUqSJL3SKXRq3yEFVqwJxQDx0uAoSV8qDAUgCIFubBCYMXmzyJEgJjLLrCYReS0wS1nszhK/8dNvIZq/xF1vfyMnXnie3a85wEf/zR/z8AsLbJousGPreuj0OX58hQN372MlzPK7f/UNrtuyGVWYYGX+IlJ4zCw1aSvNSD5PIgSv37WOUr5C6OTpiQx+7HC52afdt5DaQJkWo7UCSeBRK8QUC4pTZ0+RsWway8ucuXARFPzI97+FDWaXgzVNu7/Cs6db/MdH5zj8obs5dMbj0198jCiCj/7eD/PNzz3FeRfibsLI2DRatcANSJRPPvFpeC3Imti5PEXd5V0f/n/QosWvfuB3+f3H5tFEjFZrmLZJv1Xnu+86QGN5iSMLHXpBjBeG+Im6EqIoB7yjq9/3VZGuEAZijXnP1T1Tmqqb8rOEjNDqWpO4lDUuhCAMrx7mW+84iGWkREvHymOYIVEcIpMM2oYkigfTtYFWBqYFhhHi+yCFBSLC9zxMIck6GbpJgikkjpmKbw2t2DAyyg/+wBvpri7T6zdpLbXxeqlwtjl/grxVpuMGmCMbsLVmdNduWvU6+XyV6lCZolRkJbTCAD8EiwBhmIyMrKPdaZIvljHReG4LX1tksxb1pVXyxQS3GWISM1SpUamYkM9y9NlzoBICAxYuN/mtj/8V6uWzN/4761rCbLEwSa8//z8VfdPXRup8W/3D1zfS5a8Q6d4hgyRAs6ZW1UoTAFKBSAZwv0zZzUqBJG1IUqeoTkoBMEikwhQZTg4P8ewlly2jGZqepBfHVEeqONJmSCX0+33c3iIH1q/ntlft5cRjPksvPMv//fvfovm/fZHf++Br+eK3Zvmj2VXGHuvx6lvLLHdDWo8cxy4U2bxlBxd6dQ5s3EJkjPPoE0+jbYi8mJZhcsctN/NCfZV1SQ/ltRG1Cc7UfVptRWVoiIxVJFd2Buxml4ULz9MfHaNWKNLo95idn6OQy+D2fA4dOc7tr97NAw/cy/T0MF867/KH37OF+56d4aknL/H2d30vn/39z/EHH7mPm/fuZKsniMYzrDTruD2fStbC73bwwh6lWpUbNk3Q73m0+gZ/9uFfIVeZ4nPnVjGzBlqbdIOAt7/iVvxui0TFdK8Y06WyGh1fjeheu9Kl4ttvP31XG1L66kgpAlIOrnQiuYa3tTZJXY34vrYsYQAC08iQLedJfEGiFa7Xx8Ai6afeR5aTElG9IMAQFqEfkCs66CTCsjPYMo3KMk0DQ6cC606nzdTEBjq+j+mYxCpFgS3LpBvGFGtjWEMV5hablEsF0Ip+Z4Wzz8dMbb0O28riuQHVaoGO3yY/NEJ/Zo4g6pPPltI0aCkwbQOpNKYwUVGDpcsrmFae5tkZImFj5bMkS3Xaq5rhyfVgOpi2IKMDGLKwzTJ+0v5veDS/c7UmLxqqjhJdOScvj+nO+OAHP/j3/vCh3/nVD6pBjloqqUgnIaFSekCoSdnM2iDRgiBOIfS+Sp0LxWAsV0nKBYpJl9wBioXRdbz333yA9//IK7m1FNOgwtHZOeJuyPzCIhcWl2g1XByp+aV79vLDr7uOKPK5sgKVvwAAIABJREFU76v38cLJBiPa5w2vvYlefYW3ve1WNmYUTX8JP84jCxYn6wnn21CtFbkwM0cuColth9sP3khjpY7UCaOGYO/Bg2zesRPLTAMu/SCkX19ltDaBbRqsG89TsBV5fQ6vfQknm2U4V+Dc3GWKhSLnzl8mSjS5jM11Y8McGDZZaEV88tkGP7C7yOETszz6TJMfvGcPK/MrDE8NsXvXJh598hytQLPa6LDc6lIpjVAAComg7nn88L//MH7gk89n6OarnFgI+LPHZ+gYGXKxYPfGLfT6PZ47cpibdm4miHyanT7tjoeLIorXeCdX47rTXdCAs3SNGPfaSlnfaxYoVxlZVxuQ/lv//bVw8rr144RhgONYBJ6PNk2ELclKg8S0sExJpBUWCUkUpTQFw8axTWIVEUepn7hhOVeQWtO0QUSUyxVEnJCrFDBlhnWjFYKuh9erk3UMRretp37uGMMT4wjXpd1x0UlCqZglmyunHCa3iY48HNOmUBmmXK2SJH2ypgAnTxIGZIt5VByyvHyaXrNJEnSJu8soX2PIGNNI/bOmpneSEzax7+MpiJaXcJTL2MgIz5y68HJVmgBXJ2bfD9F4QAGl/CuWyP+j64Mf/OCH/r6fveT17Vc2SL2Wxurr9K25ZoOh1Rr4kko41lTyWoClRaq+1gYJmnBw5QOwhMATktHr99OOIgqjZcbGp/jo3xyivnIepXOYuVzK4g083nfPTrZn6mStYZaXe2zYVWXdtgl81+G3f/2TnJQ5Di/3EHYOz42YHqux3FihXCkSeQH9KEpDLu0MO/fuYsPkOoYnxnjkoUewLJOjJ0/w1re+lXyxyPmzF5iamuDIkWNsWL8daUo8r8H2LVupr64ipaDRaDB/eYGZ2YvMLC+l5vhoXn3wJuKVJQ6OKj7z6Flu27eNYemz1O4itMIs58lHGTqtgOGhMp5KMDMGuUIVv9Xk0vIc24dqELfJ2ha5nGR0rMzI2DAZr0lluMSCHOE3P3eSEwtzdKM+w1aOieFR7rpxE/VWj5mFFS6vtGjHCj8cLOmRL3IAWDNm05hII0Yla4jb2oHgGscDjdbGlZ0SrF0Dr736vfj6dvCWG8hnHFSScplqo6P4QR8VxcQqIghjDCGxLIso9EniQWKrIQmTCBUGZOwcQRRiSE2iBFokWIaD5VgQxhiOTSWjeP9P/BALZw4xf2kBYcUMjeZYOdtG91xqYyP0lCZXKGGWHVQkwMhhZUwIXcJYUJveSKk2QWNhFtmvUx7bRqfXxrQUq0tzJN4q/ZUFNDESkyBuEcUGBeHglHJkR0bZvH4/vtvm2OnL9Jsr7LvhZr7x1f/K737xyMuKJf33VSotMimVhul0/ufZaP6Tr29ap7B/PHhbXmk4Wqd8ogSiAWxmMDDZV6RrcDHwHdL6CleFgRFWnoSZ546wMrkVbSRkZs9x/XSJz55T2NmQg1uvI/B8rrO7uIvHCG++nY3btnHh059m097b+YNf/zgfOhxSyWtE4pHTCu33MQxJ0+0QoJlfamCaJjLRZIdyKK2ZnZkjb2dwo4A3vvmNfOov/5LdO3dhGCbbt29ndnaWkydPsH79FKPjRVqtFls3bkJrzfTGaU4eP0Hk9VhaPE8u62BZFqPVISwdELWX8aM+urgBN7fAicU2iWNjD41wY22U84fPMzFiMrI+jxPFoCU9z6fZWqGU0+Rw8HttMnZAoZpj944tzF46zZHDdV5Y6HOpoTgRpITFTugD0Apc3v/WA7hBF0MrApXu5+xYEch40Eiu9VFKpyU1WF6rNSHstdcwmSIaUqas2YFPwtUdBPrK2VhD4K6trJMhiqBQzBLHIbML8wwPD4PQxHEP07QQSuCHEUIbWLYDhGlCDDG26eD6PXK5IokOEGgckQUdkESaai5Lx/XAtnB7XQyd4Mc9yk6W3twiw9tu4PgDD9EUmk0bp4mzEKx2cSpF8oYES5MkJhOjE/Rbq7jCoVQcoh92sXNZdGsZ3wsIeit06kvIuEvWsnE9H9PSVAojKBVTLE5CYLFSX2Z8eJhq1WHlgkuoGkzVKi9v+5JrSikTIWKi2L1yFr7THksvLTPRKvWJHiAvKakxIWWyCGJT4Ki0QUmZyiwMKYkTNYDJB7ozkYr1URpTphFFQ5mEye1jNHuSr505zM1To5ArkM9lWZhrsVi/wGv3jfGv3v0ecluniDtN9ty5n5/4hY/yraWQe4Ztbt8xzoPzEbOtNkvdPpHQlHWKhkjLwLItfN9neXUZO5PFkdBurPA9b3sb58+c4bvf9CZOnDrF+MgoSwuLDFWqDA0NoVTC0888z/d+9xtZmpsjTGJC16WxuEi93uTWO15B3+9z3a59fPOhbyK05vL8aUaKeerhOaYmN1Cfv0jYCJlwC3z56AxzXsBYN8PODZPUClnGRvO8+xUHWZo5x4mzi1w8cZnhCYUXmbT7MWcuzpK1LF5/1z7uokfg9vnLRxv80eHLWMLmxqkarz+4D1MF6MAnjtUg2lrgD3SGsDYhXeUTXY1v4pqmcg36NkBC0zAF/XeYy6cES0NK/i41RZIo7KxNt90lNhJK+RLFTIFQeWBpwp5LnCjyVg5tJbRdn6FMhigIUFITRyElO4OSAqEdiGMiFZA3DPw4pKE1F8+dwpseJ/YtRqe2cOH4YY4dOUapWGXHliwQMza5CcMMSGJJKA28dof8ZI2skOisgdtv4mSKJL6HVcgSJAoyadhAfeU07dk5Eq9LLm/QX22BpZCZGrLYYXL6VrRQ9LVCOoowa7Jp4ySrvZiZs8fZ/KqbUX/8CFJ+5x/wf7hitAbP7cCACPKdrpdsSlkrtX01hEIo0v/JUkCoSITGQiNMSZLogVwk1cDFRvpnSdI9Ukamuyg92EVIA8ysw971o/zhVx7lHbfu4eFjS9TyipGRAp1LF/iZN7+axw89zZ6nnmWH7XLhW4f48mMnqMQWGSvmZGAyd2KVPaUMN+6sstCoct9Ch0KlRNLzafY65J0MY9Uh8vk8m6YnyTgFtAr5+he+yJ133k7H9dl/4EYsy2J1dZXJyQlc1+PpZ59m777riGKfZrPFjTt3cuL8WXq9HusmR4ndLr1mh5mzx9lUqzExXuORF47TExK/6SIwwTTISpMzrYT1lSJO7LNnxOAnv2srw0PjvO/3v8DnH3qOW3dt4w037OMdP7aOlTOnOHbsMqsLS7BnjE434Pzis4zkbDaMVbltk81Xz+bp+QHrK0MpcsVAFoJKlfY6vVwZa2dLpTYres3ATcLVSO61ByYlVa4ln6Qe3upFMd3fXmqNr/RtZ1gJKw0wLdiYcUIcaRbqKwxVahB79Dot8pUaQeKitUXGkfhxhC2tVG+XlcRK4Xs+0kjj3w3LpB9DxnJwgx67t+/h4K5pGu1lwsYqG6aq9Jp9XG1jac3e215JHK8SxyZWxqYVR0xPTRF7HQLtIIRLdWgrndY8udIIYXcFnUSEHvTaiywszuOvNJBel6gNXq/P8MgYpeEEr9Fnsfc4VrVErxNw7qLHPffchRmH5CKf8vhBVubnSa1i/imP5Heu/jYA8p2pl2xKpqFADiyCRAqpSQWhA1kF8YCnIoyrkc4oMNcirqXGFIN76+Cap7Umm0B1vMJyfRlvboGTlo2TiTkwnMXpdvhs6HP/k0/z468/yM2v2cwTn72XF2Y73Huux6VexP68yRt2l5is5ai3A070He5bXEQJA6/bx3FsdmzcglHKsW58AsexGRqq4FgWp46f5tZbbuDgzXt56plDrNu2h7OnTmMj2bNvHzOXLpPFYOv4BI8/9C22bNnCL//6r3LX7XdQzOVxLJsnHn6UylCJndft5cd+9O385C/+GvWuh20EhJFCGgYZIkKrRMb0ObvaxjIdLi9qjn/sUV67b4q3HNhI0dRsyeepJwt0+jGzqy3yZUG1nOX0bJttE3m0JXniXIsXFkIm1me5dfMIT52r88XTl/jGxbO8++5XgZAoHRPKwWSqUzeGtVu7JuWkrNn5aqVSVYlek6Cky+u1xvRi7+21aWvNxyXlPq1RCr6ddudYBoI00snJ2HhAzkh9tDKJzfTGrbheiJAhrqvQ0cBWBY2UFkkUE0QRhXwBNWi0jm2SmD6BH5HJVxgfmWD/616JWJ5BdULcyKXVbZGzy5x48GG2334DtpcF06G1vMzY5n2szFykNFKiYBtYRg2vuYLWkmZzgaxVIghbrNbP06kvpIhvHGAECbiSfCHPxOZNXDpxkqwX4YzF5IpFpvbfQjZzDjIZ2gsXKI9USPJ5fuN9n6BcKtDp9v9Z7JWurZfD7/sPhFGmbG1DgyUFSgkSQ1NQqb2tfY3GRyHRceqRLFRKzJMYeCRpUzPkIC4ahDRpnJ/DnekSjU4wMjnMTWKZi+d6/Hlb8K/e8ibu/ebDnDt+lGjrENbwBEceXOK33nIDKpfjP37uWR46m3Dh+Qt0tI1lCMx8Fh0nZA2TXDbP4vwc33vgjTx+6AWUjvHcgCRJuG7PTj7zN5/h+UfvZ6xW5PQTD3PjK+6ia0r+95//RUwU73zXu7l48TwLyy0sc55f+KWfZVNthI/+4R9TqBUYmpzkX//cT7B97/W84wffy603X0/p+VOMTI4TRRFhpBgtm1yebYOSFIpZyqJAt7+KVJInTy5xyVfsGy+wu+Sybl2BY2cWkEFArVyl57nUcop1RZtSqcSYpZlZ8agkNl85tkov8tAaFBbPHDvNLTvXEwiLDAZdUrBBCpFqsAbXa/TASVOaSEMTx2tEyAF79ZpwAWmspewmg89M0t2UMfBb0oOryYsDLoHUWlgYEIErNVmnQOS7hEaPQiFPkii6fh3LMlJULQQnm8dMYhpenzAOsW2bfr+HEJKsYRG5ffpeQCFfTQ3nTEnYj8lkSkSrkqAdMVIt0+8rqmNjWJZF0G4jnDzZ4XX4zWUMu5iePS1JYlC2QZ40yKDXmEd5KzSXWnTrM2QiQdP1CZsewoZWP6baaqFih1Yc4l9oErQb9OsNxPg2FJApj5G4Tc4+9Tg3v/JGPvvQoZfFA/6PqZfL7/vSk5IgZX2KND9MCQExqYRkwH0BkIkgGShvtU45SmJgG6KFIFRXM+cFIOI0nNEsSn5kz27WrbN45M+e5IXiOiZrkubsIm++bopiNuLY4ef4/ImQ/OgwP/kXz5AvSpSyKVldkgQyeYtECHrtDplMjkD12TQ9QqU0yXy9yfTkOuqdGTaOjLPz4O1ot82T9z0IG5r03HF6/YBIC1ZW5xm2Evbdcief/tQniVXClk0bueuuu1hZqfPxT3yU173hjZw8fpT3v/OtPP7QY3zio3/KLTfuJAkjJiZrhBouXDhHww+JVYQjQEmDbeOTnJ2fww1jrtu6kYsXz7K7WmFcJ3SaDR5dXKSIZnLDMKrTZCoj2TRWwTc1rahPpx+zFGTZMVTkPde79NQGquUhcllBPQr51jOH2LJpC5l8gRIeiYR+PEDEpLgSmZQAQickCYNrnB58XwNLGlILXJUkSCFSWsdAmIvQaJW8iHQnhDGQp1wtw0iwzCxGLkFrh1hJzGyGKI4JwpRZvmP9dkY3bOXI899CZzL4rkd1ZJRcO0L5EtvQWEaORCe06w2GK2VCU+JkLUSiaC0vEjd97EKfUArMXJ6pdVmadZfN27dgVCtkbYdmU2PkNLqnyNWyxN4qvaRH5LfRvkLgEgtN5IPn+QjPQ2lFp9PF7fsIpcjKDDIUtOZ7/NuvnAU0P72nSnmoQNhcpFQaw23MkEgTb2GGsO1RKg79d3o8/9esl3QJwJCpxaxI90MihhhBlAiSOOUhKQU+KftXa4GK06tAEqd7pzXZiRaplkppQWQKIsskWmpx4Zv3cu9f3cfwW97CXC+hNjzC2EiGO27ay9ypWe49tsjXXrjIt85dppbPM2VmCXsepjQIpINSmsjzsS2LgmWyZ+d1XJhf4fzFRR765oNUkmXedHAf5y9c5sRT93NgDH7h1VP8h/e9gcX5GbrtLvc//DgjE5McOjVLoVBgfGiIoUqVTrvFRz7xx2xcV6aSrXHTnQd557veyte+/De86lWv4vr9N/Ds88d49ugZ5pabNBsrDI9VuHXfLvas20rRzDJRqHKxvjoIIdCcOH8Ba2ySwtQEZ1fbPL/iMp7JopRifmaWUs6mLgp85PAqv3z/LO//8gzrJ2s0/IAHTzb4wqEe+aJm0feItaRcyvOK2/dTqOTJlYqUqkVqxSKlQgHDHNiXKFIrX9ZQszXG9ovTStKwgMF0pMQ1vkxy0LjWvJmu7qT0tx0hx7KJVYKfhCA0thHiWDZCmwR+GuXejEM+//FPouJU8GwZBmHfS1NhkgTTyqKjiPbKCsWRYdxBikmv2yZUCZ3Ip6sD3H4dmXgY2WwaTmrbkC2C0sShItAenaVVzl84ixd6GNLCNC0yUpKvGiSdDqrRQPQaGJHL6twMS5eWmLtcx/djylJiGgqnkOPwSi+dHnVCVLdZnu0glIXozeC1+hQqNXxpU9u8nnte9+qXler+n1v9A5QAjdSpCXoMaa6VTImUWgiigVlbKoca+EJfIVqmpRREOuUIry3SLCT9vE0uVDSkwWoYEc9rMlaG0WKGxcVlgorHwV01/NpWvn70MWpmxLoszHkBmbJDXUkCIyHp9ynn8wghyWctjp0+hwpjtu/ayYFNI7x573omRgO2bfkuasri0RfmcIcmedevfArPNIlVn6FcliPHDlMbKnHu9AlyliAQJqPVIllf8fE//wI/8Z7v58sf/xS33X6QH/iRH+fcC8/y4JNPUDAl84sLDA8Pk3GylApZikOjLCwcwSoVCOOYIib12GN0uMzSSof2Sp3VYg1VKzPpRiz0WhS1ItBweKaJLmUJPEUZxQ3TFX7qCxf4o+/axnOLS+zaUuWhsys0Wx7fd+tWtFlOSakIypaNbVko3SMbhvhhhOd5CC2RwkxdAAbxSanbZGppyyBlJl2Sp41GaTFYYq+Je9d2TpBe5dbG/ReP/KblYIqEtraRCThOBp1ohJXBMUUK9fdd9n33rej5gE6wiGNlkSQYwkYIFxkrXK/F8MQIvhdi2yZWLkvga5Q0GMpWmJlbJDthYsQuqFQYrRwf20gwTBvl2IhOk9W5S0ztuR3LVMT+LO2VNo7jkPTaxCQkiSBstekGAdqF1mKPnlYU8g7TtRJLfZfR9TUOmFv43OPnSRyT51pN3jpaJA40bSFYv24EqQyMofWI+iIXzxxDKSuVOagX2wW/3EtK+R1HDF+yKSmlCUX6LlQqRdlI0itdMnCk1CJVe6f7opTjomXK4h6YSiJlauGzZi8fKIOg1SeW0FNw4NWv4C+ePMSk6PPq9dPY0TTzR58DW/Lpe79FUhT0kyxnwxjbLuIPknANpdmxdRtnL11gdHiI67Zv4JuPPEvR1BzYPs6bbtrKg+d6LF6IyHqSI8ce4fqNRT714Anefvd+/uz+55GGBGFxfq6FpUJk0OPBZ0+wYWKKW246yNzcHJV8lfseeASnYPKZL36R2267jbnlFiqI8YOIUqHI9PgEQyPD+L7PqbMnqFQqDFk2K40GYTZhKGMhLJOR0Qqe53F5foHYiOhaDjtMh4mqzaRpILM+6zevJ0kiet2I67cV2Pc7R/iNQ/PM9gN2DBeZLOXYVR7iwXMr7N1iUSjkcDIZZDZHJlGYlkWsEoIkIYwj1EDHBqBVGomUHr5BqmsiBvsjEy1CtEolJnogTREyueKBpQax5kIYJMnffuC0UOTLIzixIJe1EGZAL0rQPZcgSNCtmEItT80r8sYffyf/7x/+BwzDoNPrESqfsNcnzBnkSmXiRGPbdhrwkAgwJNlAEYg+n/uLT/Hz73gtSVhHK5ucaTA+vh1tWQgSpG1i5avkhYFjSFB9kuYsKgigp/HcEJH0iTshyotQnZCs7SAKiqjRJ5cfYvQ1N2Gdv0j7+Qt889BhpCUxkxhLJ5T37KI6nMOWCTT7dESTbH6ESqHCfNfj3/3UO/m1j3ziZQCw/+PqO92Q4B+clFLXyUCvWcZqYgWmhFincDRKo+Q1b850t4qQDKxBUukJUmMPWOAmEUrDoifRMuHL9z3Jh37mbRSshLGRcRaOPE9SLPB8kGCUBCKSVAua+VjgBjGOEoRC4OQc4iSkVCpjJi5Hz1zge97wOgp5k5VGhz/5xlmkI+itLtBaaFCt5jk369LoBvzpw6e5Zds6ljsui/U2UggmhjIE0kEngr6MeOzBR1hpe9xy3TirTZe7776bWm2EO+6+m9NHj7Pj+hsZquTJZmyOnDhNNlfkwrmL3FAeIXS7PPjYU3QCF8/3sSyLUrFIvljE77tEQQ+yNpfrDaKhCm4Xjqplbtk0Dg2fjz55Hl8W+fHY4jPfu4HffarN5oLJqcU2E8WYsS0OeyoVWq5PuTaMaWVxTIesVhjCxIsiOm5A33OJYy9V+8s0oPJv+SmZBgiFVvFg4a2v8JjWCHWw9u9rP1eseXhfW74yKQqb8cka+VwRwwpZWKzTVyaRERL4PobpcLG+yK/+zM/zrp9+J1956BkytmRlYZVSsYzIOJikceJhGBLGEYaQFAp5WtplJBaUR6vMzS5QK7jkaxmE4RAn4LXbyKECmUyGnFRkSmMUc3may6dIlMBONGZxkokRaM7M0W5cxMhYaEMibMgXHLKxZnykSqY0zuTGEnYY8krbYLqdML0lB0PDGKUaxR3biXtLXFpZZLhYhkhT3rgBb76NSR05cOf8l/rH1UubvGmReuuoBEHqdW0KiURgiARjoPwX10zxQqbLUgOB1KmN7priPGsYuKbGSCTFJMYaMliMCtyzczdbN9d49v5HWHr2BCNZTWV6gsNfP0YSGqkpXKZA0PTYOyQ4vOqBaVHM5Dh9eY6ibRFnE+7ct5uy6DJzfpUP/Nx7yPjzXJhd5mtfu8ALKyus9lv8xNteQWthmROdDoeXFtk7vZ3lZp/RWpH+sstFcZ5iziIjNN1uFxs4fuIsd918PWHjIu/4wTsYG03YNjxFLyqSOFmWzh1F1S+zOuuyf8cNLPUCDp1o8rq7X8XZSzMcPXWcMIxYXWng+z627SDjBEtKXAOybsBl1yQXmzznLpIxTF63fQIij8Vmk99+0uXf31zgd86WsYMWmUKJxy65bN+0jrERGydTIDYd7IyDwCSJFIV8nnw2h2n0EMJPUbPBSyP1UEoGjWcwAUUG0koGshMrDUkYiGJJDISZXEFn0glq0KC+jV2ZdSxsGVCrjDExMYFVKOCYJzk/P4OjOyil6NVdhooON/7oD3D+WItYh3j1BuXhaYSK8Nw+mUyWIOiRyWRSWYqCnu8yks/S7vuMj0zz+DNn+aG37sdOFEESY+Z8AlpUkwqx4ZAZtpmUuyiUJP3ZDk5xmMwEhO0LeLMB9aaP78O6IsR2FjNvUZRw++672HxwDxeeeZDaxAambrmT6vY615drnD30JP1mnZa3gKkDcqPjTI1swMwX6DfaFK2QU61zxH6Y+tP/S/2j6yUFuU/+wYc+KBKFGsQfGWbacKRMRZNSamwEwkwRHmQ6FZkDZAepU/qdBFtIAqGwNXRNgasEPZmlmkTESxcZ2ziMWlxlqCjITkywbdcW/tOXDuEYNhnbwogTlFZIkUAQ0dMmq2GfJIoJ/YiDI2P80R/+No63ylK9yf3feIa//sLXaVxeYcENKBQzHNxc40vffIZyKYcXGvzSj7yJybECZ46eolyr8nPvuJWLp46we8sG4lgyPjnKqt9n3/Q4e/dso3XuFJdOrnD5zGlWj53GsCKqeZuli+e55zW3cvebXkdj7hzHzpzAdGpcXFyiqzS71k9yw47N+K7PxeU6WiQEQYirEzKmQ1daVMIOm3aMI/2Iy52QcuLTixVmP2HrqMMjMy7v2WTSH7mOqY1DnD43xy037yKXr6GFxnRy6f5GQhSGuEFAs91Jr0VRiFJrC+r0u1kzawMBIkxV4motJCBBGGvC2/SPoAVarwl1r03O1STXUEP27LoeO5thevte7rzrdUyN1mhELfygS7/vIqUmijxy2SKXmrPMr1xmvDZCq98l6ziYZoreSQDDSK+SShAIQTZjEfsRTi5PIn1WOotY3TbbbthHGAfEicBw8pRqw+g4wSiPoYKAbuM8OdOhkHWolWyszDrIl2nPrnBxuUM5nyMQAhUZVDddT7e5iFMyOfrEc6gk4cRzz5MdnsRvrVAYWc/G7RvYvuk6rPEyq0vLtOsLZEbGSFRAuVSjXKvRbhns3r+Vx5488j/iuf1nXy8lyH1pmYkCbYIZQ2KkEdaxTJnbkE5JykgTSJQBOk5jsxMlsETKaRJJ2pjigW5OKU1OJzQVTEcuUSxwDZOPffEUP/eWu8jkPGLt8Nf3P0FJRuyqOgShRjqCuC+5ddMwn3nhIpahsT3Jnbs287PvfTe3H8jy7ne9j1fduZedW7fhm32+9cxR5uqzeBK2jEzz3NHLVEybQrbAxjGDX/vYl5jOKpZ6CVOGwb592/nz+56i3W4huj1a0mB7rYQtBReee4ZEuWwpThNkciysLNF67GmWzp5H+5p5Q8DMWbZv2c7kUJlYDvGlx57jE1/4Il6xRtF2sApZhixNux9SHqnQWW2RdQRDTkxSqLK63GLfxiL74yKmTKgUc5xbjfny8QbVjMHHjvTYsCfkvgde4O1veQ0nz8/yylsOIk2DMB4Y/0fp2zmJ41TjL8SVK5mQCZJrY7sHJElhopRGGlxpTOir8pT0cwMxQPCE1FdkLN9+fxOJiyGKGL5GqoTt103gd/eQcQWPr7SIY4VlhdQbK/grHUZ3rqO73MAxLQJPYmcdlEp3WIY0UCL1QM+VMoR+RM4xiZIYtEOxVKU4vp7s+GZCz6PealGyy3ihoJhz8EMPbSpU5OF6IeV8kfpin1xOceqpR/nCk00mN2yh6ffZNDZBcf+NhJUyxklFf7VJHLfo90bJ2JJUHyVdAAAgAElEQVTxjRupz8xSdSCLgR906ZxfYN2mDSzPz2J5PlGjTc9qIIsmSgcc2Lv3n/TA/q9eL9mUAtKGoowBwmakwZJSr/FUSLlIKbcOKQShcTUmSSiBlpI4TtBiwGsSqSi3bEBdC1yd8LlGjhsyXf7T73+Sdfs3MmpK7nv2NBkN55d7vOPgDkQpZIQs7/vqaUqmga8DCtkKv/Fv307VUfzUz36EPdvX8/nPf4ObbtiOLSJ+6I23IayYlaUuX33uInvXDREISZz4BD2fsXKRmXqb6fEi9Vafj3zsS3ixZLndQiWS4XJAJVdmafYC1XUlIg9eOHWGailHaGfJGR7nWyG7tm2hGWrOn5nhhg1t7KEKwUKX0088RTlbIdYJq90OvV6P/Xv3cG5+mZVOG21I+iSESZaDdsxSN8v9z7W5daqAJS28M21evydHdu8wO8fz/Nj9F1CzF7lx7wGOn5vnFTfdwpETp9i7bx+GqXEDnyQK8LyQvh8QBAFREl9R/Kdf1DV6OJGsGZGknyk5cAlQKU9JM9hDXevtPdg1yTSCW35bU1IDu2QvqNNoxWjtsGv/bhq+x9DFE3TiCBmB8DxKUzX63ZhGv4UpHIQTIbSNmTFSmodpoRCorCT0YywtCLWFVgGOKZmqbqTt2lRr61g+/zymtHDnZ0lUSMbZgHAyRJ0L2JHHyNQ4yh6iIC7TPv0EX3hghSc7Icb8Sc5UFO961xbysYPwuwSuz/FTx7Cz42y57RZyIiZZ6jI0lIOogdcLCBstQrfLpQcfQq3fzsP3/yXbNt3G5js30eovsbWao7ncxRgIc//lIvffXi+9UyJ9c5pGGkkEpGO9Tg8yicaQgjjRg2w0cSWcUoo0sDENsBygcgOnSq3SL0lbmgZFNmR8pturZKyEk4dXOe738QW859YtfOVii4dn6zzRiChLn6KlULEi0vDN//w+zh6a448efpRzRy+ze9s2brlxM81mG1WtcPipEygEPd+nqyOWlurYhmTeixlbN8G+osnTPZdZF0aFy4NnYmwZ0VMOtlDUV9vU51YZdSB2K5y6OEsx48DmDTxy9CwHto4wVAx5qL7C9pEpbrpzP13fx4mm8NxnuW3/Fs48dJyVRouxyQlypTKnF5aoOhZbrtvLA888jZlxSCKPy65kKmMRDRX505kWtw6XGLJjvpbbwPyZk9zbjkEK6t2Ieucsr3zdK9CWyfpNm+j7PoZhpKikH9D3ewSeTxQmaQaZSI31EPE1aNCatARUYg6ucAphSFSsrwSIamUgjUE4p1Tpn1UJaAcpwitM8LWSUhKGPh2/x3z9MIYcRgGbpzfwXGkIde4055ZWmSiWCYTEEDHFYpHAczGNLJp0us7mc6jIR8Vgm3aaAacMFBGGaYKwaYmEfBTgRn08LKycpJjLY+XzuPUO2bEc0rIRjiTxFZIW/cWTrCxGXO4GCEPzgZ/9aVaevh9TW/itOZ775gOUStuZnN7M6uwqCptARViGIlmZJ1/NkykNsXRpAd9rs9h2WTzzAG/+8fczlJUo+sgkADPEjAOGawUWmz2MgXX0lRDPf6m/t15yp/TYf/7VD6a5bhpDDpwHBwtOIdKznnKU1tJoBYYwECLNQruCLiaata14DClCB9ixwaOBw512umuYU7DiG6yr5TnXDDi60mZuoY9ZyuJFCcoLGSvkKI8M8V8+8G7+66e/zgMPPEtfOtx803bq7SbHzje53AkwtaTf6+NEIXnTYqJUpJ4oYqUYLuV5250HeeLERaRMSBLNatAjLyRLnR7rqxZeokj6MWiD0aLBhXaHiWKZtoJux8NIQvrCxJCK6fU1NtaGePTwYTZMTjN9YCemU2bH1ikqlSHuf/w5CpbD7OwMiZcmpRw+d47J2hBtvw8CFn1B7Bj8wu1TnL24TEEYPOcGGN4yt+2/g68+foSx8ghNv0vo+szOz2CYgvXr1yGSBM/1CHwPz/Xod9u0Oh0avT5930+JriKNx0rBM3mFdS+EBBGlPKYkbVKmtFLBrRzc3xFIQw0aVJKeASMGZaCFJEniK2dm85ZN5HIZ3CTE1FkqtR1UR3KYQvHJP/sLcnkHK5chjPrEQYIOA4QwWFi4TEnkkaZAxak1ix/E2LZBnAQIxyYIAnKZPBiSJA6R0qQfB2wdX08Q9QlWl9i8dS9e6FEXCTWnTKvbIfa6hG6XsqPxmys0LzcRpsnxlYDOyTPceecOov+fvfeMtvQ66zx/e+83nHhzDnUrV6lKVVIpp5IsyZazDAPYBjM2yWCatZhueug2GNPudntIPQzQJrQ9DGCMjcHYBkdh2cKSlVNJFVThVrw5nnzOG/eeD/ucW1WyXDYMuPkwe627pHXrPeG+4dlP+IegTs+Wq+nffj2pEEzPr3Lk1Fm+8JkHefDhQ+zcs50tY0O4rkOOlFazQb2yzEJpnf5MP4ee/gZLC6cp9PYQpaCCBr/zp1/guj27OHx6FqnabIf/PyABV+4pXTEoPfoHH/iAxRlJjNYW4SsMShgruyMtNSFNBYkQCG1xDnFbnP5S91RjhN1U2/0KjaQpU2qpYVilBKng6bSLgahOQbZIhMfBqTFOa83sWp1deZc9432cWiux3NKsLC3x1Mw6H/5v76G+sMxXnz3E3EKLwFGkYUxaC0lIaGnFdKPJhfUG9VZENtUM5iSPvDjNvslu1lsGaTTjvb0M9BQYGBrExSXneAip2TU0SOr67OrJcmS5xnwj4Fw5ZrmVsBrC9FKF8+eWWSxX6O/poafLYebkDNv2X8+XP/lJtu7cyo17r+WTn/0iRgoGe/tIHQFpynKtxnCxG9dV6KjFnq5+ZCHHgS0T3P+afZQXqwQyz8zSGqlIWGs0eMNdd/Pc6VP81NvfxtDAEA889CA9hSJpGhFFIWGjykqlTrXcoFpvEEbpRtCwtttc/P+2W4nAaSsICJS46HpsdEf+BNIOV86IDWgBMgVhg3pnbdoxiXI9O+AINEvBCl/+6CdQfcMszB0mSHyiWgujIA1DjDboJCFf7LPaXWmKciFJheWwhU2y2SxJkJL3PJqkqLStkKkcpOeQUqe0tMSeq7ZR6PKYL2lklKAcwWh/L5VWA19myGVKlBaWac2vMzzmsGOon7vfcgduvYI75OPrBgsLRzl57DhfefAFTpdbRBr6CgW++sRh7rxpL55vaJTWKG6eZHr6NHHFEIZNuh2f1VaDTbt3Ujlzganbr+fo0ad56vA8a/UmVsH14nnqKDwqpa4YqJT6VqWGjsW6aeteveLrpdhQcLi0wP7XgjS/UlC6Is1EaYGrQbYxKVpbJ1wb8UUbVNkGULZF4FLRFlFty+AaLdgYzmjbZwrbTqtuJNhtrF/ZgjHcJQMGs4InmlkObBrky+dXWIs037fJo5EKvnBiDl/mETrkzMwib75mkL/76wd5z898P35hgLp0KUjBYrVC0fGpRC2kVDSiBF/BpokJFpWmJn3uv2EzTxxfYGq4m+t3biIKmvR29/GqA3sZ6C4w3pUhp8CXMWcuzLAc+6y1IoIkpRkHlLVhtlRmJUioRoJyJeJzD73Ab/7RZ3n2+ef44z/6A97wnp9nfWmOXZuHuf9V1/Oq7Zs4OztPUGvQbAagYbFUxtcCZVwuBHU+e/g8X3/+PL/2icfZtn2CrZv3MbpzOz/3sz9JOYr50sPfJJvN8MiTT7FWWue2664HIAxDWmFAvRYQtVoEQUScpCTJRVXIDjLb0kc0QqYIvA0KitaaOLWGmxsgOqE3FCY7fLcO5QTjtDOpi6vg5mjEMY1AUNI1Dv3Dw/Tt2ckXP/XndA1sIRENnAzo0EIiHNdF+C7NVg1DguM4tBJhpXGTBMf10RicjCQyKb50MQJ8L4swoITD2ZPrZAuj4BeprZXoHt6Cn89zYeE8680mOTcHxSK1+ZKl3vR6pGkv17z+Ppq1NaQusHn4BqTI0i98FC5NA0XlMrZpjNlalTiMOXPyPGeeOIrj97Dw0gWSZogjYNPQKBPX72WQXjy/j2tefw+zjz5Drx5jeaWOlN63gCg37OG/Q+aUpullx1g4h954/cst2jeOMwLaZGkpLvHr6wj4/SteV/x2Kda/LWm7lWjsydTYJmicWkKnTI31hW/jkRKsVIkQ1o4JIDGWiZ5gcIUgkZbwm3dsD2GbknTLiMEM3Noj+djz68h6kz2uzwutARaaIV2epBQ3kW6Oe2/djzFZJrIhP/7ejzC/3CDrQH2tSm8hy3xlBUGG7UWfXgeaxjBbXmff7muZWahxbN3hpmt2sXfXtbz19a/n+p27KGRczpy6QK7gccctNzM1OkCzq4d9+/dz9MI6GeURRxAk0N3XjZ9xECnMNBpML6/R5zmMFHt5/IXzhK0az3zh77jrDfez85p93Hf7jRw+P8sNk6N0KxfPgaG+flwEy/U6fcUsRSHZPDTIvHGZWVnnufOrfOEbDzA1PsJKtc57f/Jt7Nk6ypbhIR574SVq1RY6ahFFTYIgIG01CHVEFKXWQj1N20JsF7lq1qiybcnddsTtpE9KOBZjphQgrccaCiFsBqWUlTWR0mkHss7PxWWMQeiEnKlx8uknkJ7L+uI8XQMDNFp1RKtJGIZ4SpIqh0gLlBH0F3txpYv0HHwHMp5PxlEYUtu3UhLhuBuNdY0hSWwGqJ2UY8fn8P08lXqFnmIPrbUSvlBAyMrcLDmj0PkujFbkIoEjUzKVJZqzs9z5fa+m0J0wMj6GL5v0ezk70JEwMzOPFIoffdfbmVtcJ9s/wOGvfY0Xn7pAbSGmGhmWSyXqsysMjeTx8wWclqTYXWCg3zAy3sdFLsPFpZRifGjsOz+gUl6W3XRAq1JaSeFvh8BOhWF4eJiffs+7kc7FbOtfA43kO63vGDKTFGINYWSzniiFODHEiSFKoWUETQSpbLeO2smiwqb5HUSw0oK07ccttEFqTepaz/uMBIn1fGukeXTPIFsGDa/bnMHt6+FsaZXlVsDWoWFSoejO+ci4xXXbBrjhtt34fko9DpGVCq7r0+flKCUJfWkMJiLBJ29gWArmz5xiarSLSqvBC8tlqtVF/v7xR1morDO3skaakSSRZvrCBbq78kz19pDzXK4dz5M4Ai0VeQSrpbKVwSBGxXD1xDBGCtZrJQZ8wdy5Zcqrczz/D5/nq5/9U/pGdhOUm0gTkEGzZ9MUjWaZqC0HIqVDIZehUqrSatTZf8N1zK+sctVNN5IEIUmoicKEm667hjtvvY73vO3NHHnhWVqtkCSKSNPYchR1jE5iQp0QtcF7l6fsFyVwO8v2kqQNAMJmUFKkl928hvSyHfqi1Mnl5UAgDK31JYJUMLJpgmZlhYW5aRYqS1RqywShhlQThdarzSclDAOaUUiqBKXSClpkLLnbkUjhoVKBiC01xtJdNFobMjnfGqEKQaJSSs06zUaRrAdaRzh+gXKlgduVIZAgkwRdrxJNTOKND3Hh/BGuv6qP2af+Hi+MUa0Kfu8I+bxiKK/I5/N4BqRO+eInP0ffyDituEqj0WRlYYZDR9dpLGjyxT4aa2XWVlc589jXaaQxZrRIGjcZnpjAxs6LGWWH4hOEdattJQTZbBbP89i2Zetl1+bljfFOxnrjjTcSx/FlQerSJQwsLi4yOjJIksQIXCYntvDTP/PjKOXiuTZQCemgOs+lkni5PBKFK+T/tFLvykHJ2FItsfdRm/8msMh5W7NKbXAwyHYv23HbEmCXOOOmCLQSxHFKYiBRNoi5wv4opZCuQ0aANk2c+RnyESxkhzm3sEyqI+6YGqQZt5AiYXFxBV8Yzpya5mOffZSXTs2TJ2TBSDKZDK0oZqo7R58HyiQUlP1batpSKRLfZaVSQUTwx19/muuu2U850ihS5heXWG+0EH6eSivgycMvcnr6BI/OrjNTqtHT00NLWd1xF0O3l6Xgu3QbjdtqWQ2qKKZRbfD8s8eYnZ5lR98Af/aJj7Dv2u30jIyisoLNkwOkQUpXRmIcwWq5jEYylM2yeSDD44eO4nT1wOoaL55b4uknH6OexARJSqsZItOEW2+7AS08jHARykFIjzSGMMWSYC+Rtt24pEa0qSaXDqnbUyEtLI4plYgN1UlpA5UQVsUSS514uY5SZ9XKi/j5PtaaLZLEYpziOGG9vEZztWb7KFKSEuFlHRKdIj2vrXQp6S4UEXGEEgrd9rgXynLtXOViDPi+fYCtqoCmHqcIYzhzbo3czlFimUF7WXoH+yE2KJMl47ikRuFki4xNTqCjlLEsmEyWuG+MJCdRwiNcr9FbzLJn0yQiTuj1MoAk1SFD26bIu93oLsPgwADGcXhhvcbJ4zMoYxia6CI7VKCYCOLnjlHoL3Jq+lz7XF6endxxx+2U6w3uffU9GGNotVpEUcTM3CwjIyMbx3med9kmYt1mBKurq5fpq7+8DDTGcM+9d/DVrz5g2y0y5lX37GXbjq0cvOsWuoeGQMA9d9y8sbF4jssv/Jt/Q6GYITYXy/bv9bpiUEravSOFQClJakdsbYEvg5DKjvgNGGmlVjuDNgCjJMpY4pwQBkcqfN0JYNbxJJagSREmIVGKAVeinRTpRHzx1AILQcAtWydRSnJ2tUy1lTI62MXZuRJ9xTwPHavSMLCGJCMFgSNJkgTlZUlyRTxHcHDLEHfu6OfqrM/+wSLTc1VaUcj2gTw7Bnv54Mc+R96X7Ny9HSM9Cr7DaM7w1aem+dl3vJNb7rwL5TjkHZ9i2GTX4Dhuoi2vKYnY2+WRcSAo5Bgq5Ml6Pr1ZyOZ7qa8t8+kHH+TqHh9H1hjqdhiQikeffJYfu/9uHKFAC4SnWKxWaXkKiSQKQ46dmeHJl87QU8wyPD5JTmVAODiZLMbPgsogHZvGS+EQRQGk9nslOrmMRiKEat9k6SU9IvsjOyBK2YF2aLSIN3pNGIlBWtv19kPR8X97+U07PjiFijQFCWGriRaScrOOCiLCsEUUxMRhhPSt2JqUkAZNXM+qZUrl02zVka62lBcDqRAYpBXQiyKUcgijiDiOaQYtnNTKNB+avsAzjx7m5OFpbrjzjXgiR1dvF7nRzST1GgM9o/RM7kBLyBUyXPPD/47C6H7GxqeI52YxGZeBkXHq9Tq7xrLcuHcTTpSwyUje+e53UcxlOT59hqNPllg4s07R9djsKBLtcu7cGrVyg2JxknogWXd8cl6R+YWS1fwRF4OS1ppHHnmUndt38fxzz20EFyEEcRxTLpc3ju1IHG8EHWM3kNOnT1+WIb1Sb+r82SUef+yQdYvRkl3ju0hagm98/RFW5lboKuS5/4fejNagJGRyWWpE3Hn7Hdxw7YH2ffO9D0pXnL598/f+8wes8Ff7pKh2FtQOZVKaDdSwwALpnLZjiexEcQyJAGUkiTTESuAiNsCW0ljAnSMAoXBFitYOYypl0WSpxQFZR3F0fg3f8YmShCSKuX13H253D39/eJasl6cRGHq7u1BGk/U9PM+h1zW4ShDEhqnuXmLfYbopeNtr7yZJYq7esZvrr93PM4eP0ggMzx8+ghtragj+6pEj5LKCLz/9Ek5GsVaqE8UNKkKyuaAoSMWQ7zFW8Cm6cKFSI+dlWQ4SRvoHUPkic+V1WtWUF84vcHDPGI8+fopnTq1w1+17ePHkPCRNfutDH+DIM0+yHBp8EyMiw/axQSYKOc6sVhjtG+CZYyc4eMuN4En8bBZXqY2bUWpDGEW0mk1aQUi5HlJpBTSCyFosteVH7PEXCbTGKCBtA2A7siSdiY5zSXnWMRjoXHdLwha0MSGa9mZl19T4IF4uQzOKcf0McatGxnNIUkhjjXECoijFFVZ7S3kOSknLCtCCMGniOIpGM0J5PjqNcTyPrMjgZBw0GpPGGJGgpIcU0vZzfRfPy1JtJBw++gLX33QHYXMNmQY06gGV9QuMDfWRupJWElFerdNcqeJ5WWqrF/ByA6SVJQoDUziFmKg7x+59t3LNzfuYGJpgWGtO/fHfsk2NsuP793HV9jz9mYR6OUFEMVsme8ht9ti0Zy9Rsk7/8E6OXTjN15879y0BQwiB4zgsryzRagUve+osxML3/XZGenlQuO6aKZZW6ph2JnOlRnmptEaHPD0yMsyhYyf4zGc/0/4Ohje+8R7+5I8+RqzthhCFIU899gS33HwAJ5fj7Jnzl8E9/jnXP3n6ZoTlryEl0rHlirAKEjiqLblKmwsnsTstGuGAcAxSWDkTCSRCo4Sxu1qbumB7ThZiIAChU2LtUvRTPOkw7sVsHRwniEKk67AeBghlH4YHnl0kqFbRJqEatBgfkOTclLzyyMuUEd/H8zy0n2e5FDAbBcw24eqBAf6fv/1bzi6v8WcPfY3PP/4EN1w1wlqlwtX79/NCvcLxhVUGe/IkyiOM6zz27FGkCQgSjVQOgVBcs3mIm6b6Gck6DHZn2L19CwN5h9GRSRbrdbp7BhgYGmRk61a2DIzye187w723b2Wkf5iTx4/wmgObOTa3zs/90q8zWw74ydccIJU+1Tjhq0dOkvQWyGZcSuUqo0O9PPDwo/RkMnhG4EgHZQQOgiCJabYCojCmUm9RatRoNJtEUdTONF4O2JPt0itBSseOlIXe2MltRtXOpi7tCSq3LQqX2iAgRVvV+/KHopk20DLGlQp0ipAecWB1iwwpjnRxlUMQhmg3xUljaCUI6dF0BL7KEhmJSWKyjiCb8cg7GVAJJtXI2BqaSmMzYikVnueRVS5Bs0GcprhFl2effRZDSBKD5yoKk1uJlKYrk8OXGbp6BpjYuxMnG6F8SWX2BSrNMuXWGv1ekaF8P+Xpp2i9dIi1J7/KztuvZdeeA2y78yA9IzvAzUM+Zuu2LrIyZfp0CT9QrC8ukPcKONluBrdt/7bPVqdJ//L15je/HrDT1Eu9+qS0g4d//4v/pe1c/I9bi4uLzM/Pt6+xwPdd7rr7IH0DvZdlW1JK3vIDP8T9b3ozcRz+oz/nn2NdMShJ2eFH2dJMOgLfAaTAacukKkduBCpXCnwBviNwLynjhLDuJq4ARxk8aTlyHecNiaBznj0R46UGV0iCRLBWLbNUCSHWuAi6tWFndx/9vQWUzKOFR8bziGua9bUaUsXkMoJmHLJUafLcmUWuvWYbdZNF6YB/OHUEFaXctnmYV+/p56Xzy3T3DNA30M+zh04w7Pcz6AlGujzunRph30Av140PMl9qcsO2HehWE+F5nFicwfiC/dfsIoyhUS0hMj4mCVgolXnp7AWSWPLkSydoCsNYby9fOrTES0vzrIceKttLFAoajTWCOOajn3+Un/uRu5kYyNKTyfDIoeO85pab6ZsawReC6fMzINTGBDSMY6I0QacpsU6otBrUajVaYUQriUi1lZ2xmCNzSQ+pMzGzlBOERhm1URZgUr6lLBPa6nEb2b6BJaItBvfyBmu+2IeODFEYkERhO7jFuCoBDGGkMbpFxsuh44iyTtDK7uYFowmFpuj79A/2oXWCJ1xaqSGVmkSnuE5nWJKSyWRwXHuvRGmCL637iYkSvvLpz1Kr1SjmCrZsXGuQNFJikVqISHeO9elposWQ5tIxKutLuJkuklaFRz7/BRrNdaYffZ5zjx9jbGCIo3/0ecb7R3CqAZ/7s88RxiU8wGs78wz1F0i8lMq5k4RhyNkLj3P2xZVXfK6ulN18/vNfZHRkaGMz6JzfzoDhI3/y39Gv5G31HVYH0tMJdGEYsbq+zm13Hbws+Git+aG3vp13v/tn/tGf8c+1rtzobiO2PdqllrZuGQ42uxcCHK1xBaTaoLRBOLYU67APRLukc7SN+K6wgnzCtOcRGzw6gaNMe1eXSJVSjkKSxMFzheXOCcPO/gJrUZ1G0OCRY6cgso2JTL6L3v4cOenQaMQ4OY3s6eXgrft5dnaNiZERChmfoCm4YccmZKx47a6r+K1/+7/y+Qce5fTsLA0dkGuuQRDSbEV8c3aFehhzfm0VV2pOLs2jHZc00RSdHsLUJ2wGXHdgF11dBcpr63RnM9xy1XbQITGSoJEQGUWoI0b7p7jvhl2sa8PgYJH3/PD9VBoJaZTQl8nwu3/x98wsrpJxJPlsjtMzC3SZiNfdfz+jxQyNoEUYRzSDFkEU02y1qFSrlMsV1terrNTqlKs1oiAmjdt6R+2+4IbWNmxkQFrbiWoHLGnBsZ2GqoVwSGEwut3Ulm3S7sZUr03KvWQ1WnXOnT+NdARCOEgVE8SGIDV4UlgbLuFZ3p3SFJRnMzep8LMOGemSGkgTYYOsbqFEkyQ1hEbT0iGu6+JmC3gZH4wLWkIUEQmDcBTaL5D2+8wtNEhEk9SAcRKi7gy5zCD9vZvI5iX+4BCNuETz1BpIlwuHnuGFB75ModjL8599iMZiwp2TtzDedRWbJ3bjOA7R+irdmW5Gd72a8ZuuITfgsnlvnt7hIpXFmMGxKQYnBhke3cZ6q37Fx8txnG8pzxzHY3V1eSN47Ltqz8ZzlKYpY/0T/MaH/ssV3/eVVucZu9gwhz/47/83n/zEX3/rscn/nAZ3Z32H8s0GlxgrUaHbOkmpsKBJYayJQCoh6yqQ9vdOpz9qQKBRQhALkMZy37S0ErlsSGVA0uHIAbFj9axvywpqYYUotXinvFdkMUro8x3m6iH1VobubIYRx6U3oxhSDhVitu7bxb4bb2EsKyjGmnrY4uTJZ7i5x3DPji2szMwxMeCz98adfO6BL7Fv+w6uGhnirffdx/VXj6C9LH6c8HP3TPK6qZS+OGRXj089SXDChOVGwJG1Mg+fneNjT53gC89Ms1Rp0jc8wMr6IuWlRfLZHIV8hoHhXur1mBPzc7wwe4HDMwu4mQJffOwIc3MzXLtliKFcjly2m2w2y2wT1oOA7UND7D9wNXfce5DG0hx333YH9XqdWsUSe+v1KqX1VerlCtW1CqVGg6AZEEX2amkSG3i4pKmN7VGkiT1CSRugNpIdLTYmbZ1pm7VlSjYMAi6Scjs37eW3kONn2Jbs9U8AACAASURBVLp7JxqFdCShdhBo0ihFJyCkJJGSJBbo1DZ2E2xJFgUpqUyRRpPGCX093UjhEQZ2jO4ZB4HCcwVpGtOsN0BrEjRuJotKBbkgpZhRzD9/hOW1MrFwcT2PrrFNtMoBS3MXQIT4PYM4KiapLhI6EMcxw1M7ics+R8+vsbwSM7h5DNFVZMDzyBnrAV01Mff+xA/QPdxFwe1GeJJsMcXviYnLMFDIUG9p1pcbYPzLJlidrKeD0r60hOsckyQRUWzYMj6OMYbx8VHMhtSM4PFnnmFgqP9l1+C7X7/43p/ZuN5rq5VXFKEzvHI29653vet7EqyuDJ5sN0l12p6wtQGTIrGgydQISK2bSZi0XTJSaLUndO0uOKkxKAGBsRy5sC2V2zIQArGxn5G29bxlZD9sxDfcmrOUjIOeIdUtDmZT8iLL5sEuhgZ7aGnD9Po6/8vrDnL//a/juh39dBOjS7MoJ0H5Ib/ztpt43U1X88UTK2zqWqOrz2WsN2Vlbo47to9xz4Fhrtuzhbfs9piZL/EjrzrAB99xHU8/co6aP8TW7WN4A1Nct3Uz1x/Yxb7RHl597RRXj/ezZ7CLfl8wOZRn9+Y+Dkx2c89dO7nv+mHW5uaoJjFOJsNNW3Yz2NdLqR5RXqsz0NtF0DKUKw3ON5skwTqTGasAWUsEz549wzcefYxauUQraYILleoKpfIq9XKZVrlE1GzQCFoESUwap0Q6QSjb6xFCchFCZEs2gQtaIduJjzYGnUqLCeqYCxjHEneNRepbDlxnR5e2ukOiv12TNbbAtrhZtQL+aQTKIetL6mGVtgwBRoZ4wkdrTaoF2ZxDZACjyKssvp9BOFniNEJLQ9iKwRgyuaydFgkHx3FRriRK7FQuMjEt33Ds+Ev07t7Ciy88R6Mp0UlIYzlh8eQMopBDxCl5r4d6pYTre4RBjJfv4tz5k0R+SlBzyOW6+PtjZxkfH2cg28umV11Fz/Yd/OFjX2DT1BZ03KS2WqHQlae7q5ehiZwtaQtDJLFgvdLk03/31cvAj8YY9uzcQW9PgWzW3/hdhypy6RTu9MwMAHNLq5eRnicmNnHq/NlvTy+5wtJas3vnNfzIj/zId/2aS4PQxz/+8e8Jd++KKgFx0vlSBqKLX7CTKW3smsYgVPvEaY3SEGFxL5p21G1jm5L2f1MpSXVKmliSqJLSGllKG/hSbFPqxj5JaTllZ7fhZDVDr1tnOU7Z0dXPiVKVHcM9/Pb7f5m/+fTf8tKFVe7e1cX58wvsuukAen2d7ZODCNfhR996B/dcNci5lRLBQ4cZdF3mTp/hNrfA2bRB75DPzIsv8KodE+zOrfOpr5zhayspe7Nl9o4OM9TjMtE9QGKaGFPg6UPTLFUMw+NFpInJO3DhXInXHDxAj4o4cuYcoyomTD3WS2V6xjfhqRJDXVkGCr2cOL+AP5ny5tfczd898ACNlqQWhggDgYY9U9uoV2uIetNKv5iQSFuenjaGxBEY4+BK1W42mzbM4qK7rXW9EuiNMT5oYiQK0zaetMaVIUr6GJFYvpsWCGmR1NbrrVOiiW9xL+Fl6oquyBA0Db6StNKEnJZEpFSDJl3FPK1WC6MlxaygFrTwvAwkKfV6C991cJVDaEIc10cJSVb5pBi8YhEdhWBcdBrj+YY4UYRhC9f1MXHE3OnTuK5LLuMThmB8zYc/8j/oy/ncsP86Dtx2J9W50/isYZoOWRTVNGHfTddw6PBxMn09rD1ZojeNaKB4//vexo9/6PdRUrL5m0WM0+A3/+yjlGrzJHPTpL5P797bmJraTbz6HGnzKYp9I6zGLg2nyHo7E8rn8zSbTTLGsHT2LOU0YcvWnZybPmVpWZegrDvPlOM4JEnC4toCOzdv4uQ5O8V74ukj3H3XbRQKBWq12j86SGQyOW67/RY+/vFPfFfHd95ffQ+lfb+jRnea2IlMonW7ryNQut1J0G1iIUDSqVulfaEj7UjTAMqWeLLdwI6NIUXjtDXCtLR6JqoDLcgIiC2GqdQybPcMA55gn5fwcD2LzAmm55e48fq97Owq8ge//VHefv+NNMMmjz73Eldt6qeysMQdB/cR6CyqmGXx7AXGtw3RN9FNIUrZf/VmnnvyeZ4/fZZ8d57+oU0E3X0M5Us8cnyRO267hrtvl1xYrDNa8Ljjnv2US1Uef/I8sSxw69Uj9PZuJjvQxfryHPu3DJB1JcX+QaaPniDJZDl1foG630Ok4fjKHKsrFbKuy5Kpk8lkObW0SvTkw9y6ezN//uQpVkoJ0nVIo5h8zufFc6e5Ru4GNNmMi5NYN480TUmSEJFaAoMnfJQOEEagU9nORFIbQNquJQBaJ20HE4vMti0kK6YmRAoIjLCjeSE6kiXpBgHXDizau7tqb0zaQgsuLttkV26OpQvnGRsbw5MGkS3SbNZx3DxSahLh01PM0myFKCUQUqFTgfAkJpAgINIJjutQq9YpdvUSmATXETazbk8JPcdHRw0OHTqEl/EZ7eu3HM00oZZAJCQL5TVcB5bW15Hr6xSGcmQzXSzreZRXpK5y5HxNoxZTKdVwezP09Biq80t87OO/y1y5jOsodLrA7JEHIQgYHBhjeO8EKxfOEMcxAzvuY3OlSlO3WK23WFkL6KgFNxoNAFpAECcMd/dx5txp8n6GRtxicnKSCxcubDz04+PjzM3NAdCbL3Ly5KmNHhNhnQvnF/iVX30f73/frwJ2Uud5GaIoIJ+3gf+VqCTGGP6P3/wNfvk//vuL73eFpRwPk8S85uDtfPWxJ192nf/l1hXLNwcQxnal2wPjDRWei3+PAaMxRqOkzaq0AJ2kOMqCLtHgtvEusbQPg2cMjitwlcDH4CtQ0qCkxk/AkQbX9fF9l/EeRUlneTFRLMaGiaEBRsb6OXHsJJN5zU27ejg7fYFBP+TV995Kgyw4Ma6ryMuY0swFlFKsnF8jPHuaTcMuj3/9G8ysRRwqKV5aSfjmkubkWomHT1YZ6OlhQJc4uDvP21+9jS63xhOPHObQC8cZ75tkx+Zt3Peae8jrOkM+DHcVOXHkPM8/N83XvvQwawtLDOsmP3TvPm7vaVDMJPitKjsHuymHNUQQEocJA5ksGcAxEaNZ1+oYRRrXlTx95iXyUtHtFujq7kU4WbxcHsd18X2fvJ8jm8mQcVxixxA7glRIS7KVyQYz/CLQUaOci6YBnRKug+TGWC6clHJD9njjFmmbDnTKOrDjeNPJqC5ZGb+An1UYkTA5PoyQDjJbxMHge5ZMjbBTsnKz3r6DUlw3xVGW8uL6HokJcTwPz81Q7MlQr9cRwhJUc3mPZj0gSSIcFXPoqWcY3zLFwNAIzThk+tRxHNcnJxx6sl2gcjz44IOsLtQoradki0NUVhfx4hY9vYP0je2ia2KYepgyMDlMtj9HahS6tcL5ky8ykFP09fp4SUqrWUfl+qi6hqGRESa37iKII5priwzuvJUTh5/l2ReWOXb0ND/whtdv9JE6ZZnnu+T7u+gudhHqCKHh7Nmzl2GSlpaWAJud1KoNurp7NgJIolM+9ud/wa/+yn/i/e9/vw1Ivtx4/S+/7z9YsOQrrO3bt/ODb3kD1fJ3l2EVCi7/4d/9NHe/6aA1lfgerSs75Kr2VMaxhFoBOAhSKXC0xah0aAMdXpSwW6nVX9LtjEhZSyYlJMrC35C6jYMSts0g2jonwkCMxlGSehKy7vfy3EqFmQBcT9NXEOwe7+fQiUXuu3YzX3/uOK8+sAlXxmzesg9HJeyb3I+DoNJUFDMK2dcLzZA0atCVH+bE8y+y6g3wl8/O0zs4QLmV4qy1eEn20WhpOF6jtFwjCH1mZp6ip6eHbdsmqa5pmlGAW+zmSw8+Rb8rufDiaUrLsxgUA8M9CBzmSgEiiGnV6kzPpNx5+yh/e3gV6mVGs1nW4pBeH5pasrgS4OZ9qkBRCKpGo42kYFzinOJjD32Vm7ft5KodW1BC4RiNThNS6eAkmkQJvBSc1KB1gm7HCGFsZmPPaxuHotsKlCK9rE+x0Z8QGpOqNoTgIo7MgmCho1zZmcwJKV7uG0A9aJHqFo5wCLVideEMI1M7yDqSOIXQ+BQclzCOcISDk/GtxrKxVIxUB0gcMsoSciMT4coM9aSM6/QTRQFBK8VTkpeOHSaTy7F571aCFui4ilA5prZsAREzM79K/0gfhUyWchDxxEOfY2JqN2PLywwPdiGzU9TWVynXVnH79iBXPsPO3V3MnjNkMx61epkxVSOplmmW6vQMb+Lam9/Is88/jHSLLC4s0+NHeA5UEXitGsXha/mLj36UW191F36hiO/7BEGAEIKuQjdRvQRpQrVaRZOi2niuznWAy22OVteWCaPLA4IQgjAM+eAHP8h7f+l95HLwgf/0IYyBaqXOW9/6Vj75yU9+S7l17tw5RocHWFxZv6zP9UpLSsnvf/gPKWQdgjS0/cl/+XaS/ewr/aMSEtUe4btSWNyRtH0NobA2SsrKYKg2Wlhdcpd2yJLQyax0W27CNsGdtnDcpZxOI8BVEp1qVGzoTtbZ1NVHT85DkpJ1cizNrzGWgWOHp/mx77uBqalRBq/aTbHboZBTCK+LCI9CDmRWoLyUzEAXuZFRalGDTLbIHz5wmIpQeCObGbn1TsZuPkiMYr7eZLra4usXmrSaAdvG+rnn7psZ37WN9XqN0d5++ryA+267jltv2sfU+AgX5jWztYjVyOB0DbFUbfFYPc+KV+Som+VPn5xlLmpR14I940NcPdhLOZD0KUN/schsdQ0Rx7z1uu3WMy82VFshWwZG+N/e9lb2X72XTD6Pl/FxfA/l+xRdl9SROEKSCENkrOSwcgRKXmxyX+aA2/Zxkxu8ts4xNvuxmRJ2Amdol2zWjNRosUGX6DS9L7724mqmAflMEeXn6Mpk2LZtGySRlVJ2JL6SWC05TYI1O3WkZzFQnsJ3MziOQy6XoxFGQAYp3Q0YgSNdhOOSNhtk83kKXV24oUuaxrhODk9ax92gZdg2OsLKzDnCSoTj+nT1FEnI89QjT1Av1VAZRS6jyHpF8n7Czu+/n4wagighiEIKqovEzUG4RJq2kAbmFy7Qne2np2+IkYExKuU6ca1JfeEcM3NznF+r0N9XIEohWmkxOTmFsm06pJsysGmSxcVlHKmQqUS0G92dnk2aXiRCa60vC0gbfcG2akcYhvz6r32IMIwZHBzGFZLPfOZz7L5q2yv2f5Ik4fipOf7hoYfo7e7BXCHKGGMoVxeIooSkGfDeX/yFV9R2+pdYV8yUhLJ9H4T9+kZ1RsR219USiwbWwg5tNCTG0k2ENnaXbk9pHMcKxQlp9ZWUUm1vevtZnelDByGcGBvUVJpl2DQYKrY4FuUZL2Z4aXmV9UaN//rmAxw/fJbXvvEufuV3PsHerZvISMHEUC+uI8i4At8TOFpTrtTIZjzQCjfj4veNcKFUw58+jiwvUix0s7a0SC1skVGCxM2xWmkyPDbI/OlFujfD3h0T9F41QlMVWTq3xECxyMTEJt7xfQl7b95LcWyKRiL4/lhw4tw6v/De/8pyknBNbw9nV1ZZdSX1pTUmRgu8ff9evnFqmdTAqdUavpfl7NI6pAY/XyCJ6tSDFk889wI3HjiAalttm9SWWoFMINUkSUKYWrRzmnSyIVBaYezFayO0OzglOznbQAu3syGdds5/W3db2YzXtI0r7RRWoByzIez/SoTNjCOoxk18N0dNWhGzNCijfR8hHTxXE8cJSkor3hbFpMbgiQzCEfgupMYhSlKkIwijFq7vkleKbMalHIc8+dBD7Nm9l75iL4ky1MMmecenRUw2UaSuRyHTJNQOE2NTpFqwVlnj6FnDgVscRq6+g4VmRL4pyA5vptFo0Z3fRiEJmUufpNjrIAwkbkD1+CO4E6N0DU6hMoKsoxnauZupLVu4cOowab7I2tkvoPtvoy5h+sI5skKxdn6ZN/3kD1J5oE51dZXF9VV83ycbaG48cC3ffOpZPFfi+wmVhu3hCaEtobzV2ij3LhOGQ7B12w5OnT552TnfvWsvpVKFxGje/va32qmkhFfCWP7O//VhtNa8+6ffyZ/+8V8Sp9G3HtReSjiUwzqPffmbnJw5R39/P8vLy1cKGf8s64qZkgBSF4TTxle0e0qodrbdXlaC22zIlWhj0FJYLW1tSIztahiE/TGGJLJw4855M0aQaqtIEGkb+LJScazeIkBwJMqSSp/ptQargabfyfPXT57ihhtu4Hd+92/4sTfcxWQRXn1wH/0FDa1lVG2J5vI8JmxRLVdYmV2iXm3idPcyu7pOkMYcPnOerx06ymcf+SZHZuaoNiKaJmEsl2HHpi4279/G5NXDyEaJkRuuo3tsB3p2gf7+Xg499iRyqJub3/F2qpk+5uZXefZzD/BXf/QH3DCZ8pH/+DaOf/jd1II6OSXJZovIgmRyZIhGmPLD121lvVXhZG2dnUWPVqvBfVeP8/ZXv5okMQx2dTM1uYms6yB9h1TYHdWRhozREIcEUUIcx9a2up2tGmHQjkVgdzhtdiCR2kZ1G6/Umfp07nshDYoUUqvnLYWx7yFSpAKp9EbZp43FQQn5Ml6XBAeFi8JNDFkU+WKONElQMrXCbY59CHVkByGe5xOhcV3X9p0wCGXpI75S6CQlVR5Hjr7A2qnT7NqxG6EMQRxg4gQ/m6HaqFgeoKNJREwUSaphAz+TRWpJV18Pxgs4e3waIVN6h0ZoOYJC7yTGKSLdLnKD4xT7ehifKDIy3o+XxBQnNyPdDPlCFl8odNJCipgoSujN5cilKbnBg6zOPsuLT53grjf9IAfvuJmfeseb+R+//ttkywFFJbhh77X84OveyBt++Afp6x4lNSkjA/3cdMuN3LT3KjI537Yu4ouuwy/PQjUGz81z7bX77bluB653vvNdRFGAEJCkVnLlwx/+vW//XAvBpz79eX7jt3712+KOjDH8xSf+js98/K/52Kc+xeOPP/Y9CUjwXegp6QR0aIX6I21sO6LTRpUW+KjbaO0Y61hiBOhEk8iLeN801aTGcuM0oFxJ3EYYp6L9YwdHaGyf3yVlXx4cP8epcsT0eoVTpSrVZpMfvmUX7/u3P8Xg7ine/KabkCYkm1Ece/55ps/OMV+JOXyuzNNzVT73jcOcnG+QaJ9cV4HBbdv42Tt2cO34ZvJZD+g8SKB0SpfyeeOBEYaGJ/CGR5g5sUhEnrXDR/j6n36cU6fOM7llmFt//K10ldf5yu9/lOD8WVRplete+yp+6ld+mVbXJj7+11/ipa8/wsHxHJNDQ2SkpGlcyuUK2XwvkWnwM3fsx0s8TtSaDDiKHZsn+eSXP8vPvuNt9A924SpJrRWQBhFoYwNQnFALImpBRDMICcOYONUbvQkrAdq5tLJdtqUIXJsxoWxJhv0dRuK4sq0Saidwwliibqo1OrVqkwKF1iBRSJGxH6VflikZj6xjxfb7/DwN08IYwfLyPEkcWmqStEjxlDaUxCT4nkD5BRpxiBASqRQiTch4LiLVODqkGQYY30G4Ho00QbgZgiQliSL8TJHEpGQ8r53lSHzlUIsCIteWrAWvh1ZUY3l5lcriOeIoz9LSEv1DI9RaAUa5JGkLHEP/1gl6BvJIE9DXP0bG76K7uxshFNX1VWbOH6UWNghli4gmmeJW+vfdy5c/8mdcfct9rKGZXV7muZk5pldWODUzzfzMLEmrRkvU6e0pst4s88KTx7jz3ltp1RobQNdXWp0AlB/Is7ZqG+E93UW2bdtG1nXtdUbwyb/8c+ZLNYRjSdueZ+/vDl7KbkKGernC008fbgOWX1k76bFHH+ErDz6EJuXS+Pj/FUDpuu4V//2KKgHf+L3//AHaqO02Ig+jaYugW/kS6PzBnQBj038jLGnSCGHLBWNlOTvWTAaDSSGVAoFE057wGRspjbCeci7gpRHF7ixKeoSpw+1T3Vy3ZTNDXhlCzeyFC/hZHykcKk1NkinSSCTFbI5No33oKCbreTTWl5FK89JjJ+kqRvzx42fQJrW21RhcqVHKoV+E/Oi9u/ClQMcx68trpI0mTneeTCI5dfw0stVg7uRJ/KzgmrtuZebUGY68eJyuXJZGaYWZv/kU19x2LXve8ibqSzN87alpNo30sn+iSKu2Rqle4vxajYm84nCpwexak8lejxfPzHH7HQd5afoMe3ZfhXIdlLI0njQKSZOUIAgIGw1KpSqlWoN6o0GQxPbaGLmBjO/QR+xN1Cnf2iWbNHT84ODixtJZdghhkEpsZFd2OxIIkWJIEG1y76X9iy3bN6GEouD41JMqfuTRktCVKyAcH9dx2yRan7znE8cJbiZPIZ/DUzlc5WHSCNMKiUREnCacOnmMqNGib3ScSqmBFgkFJ0MYNvCUpJnEuEKScTMkaYKjDb5RGBMgldPGZYHjGoxO8LNdjA7mSCmTV32ofAHdLLN87jzeSBFfSSBDNu/QO3wVjtONzDqMbdnBarlC1KgxPDJC0mqitWDimls4dFZQy43RXDjBhdIit931Bm6+aid/9dnPIJCQJvgmxJcxS7PLxFFCfb3KNQd20lMc5qlDLyARDA/0UW80N+g+ndUZRjTWKmzfsoNSZY0dW7dw8qXjvOE1dzN95jzaaKqlCo889BBf+uJXeNd73s2zTz6F57gkL1McMMZw9OgxPvRrH+Thb3zj20IILgV0dtY/NSh13ufnf/7nee1rX/tPUwkQxtJDjBYbO6JQFqGN7JBpaWvwWAqBNsZKW6SGpC2bADbAaCVINGgkkW1F2VJOa3T73YywjVBHShwUFQO+0GyLGrSCBkM5yZv2jbFv3ygzKys8ffQ43fkCh07M89K5OZaqLbJpyrZ+l0bUZG5+lTPza0z2Oxw+XeWZp+bYetUQOyfGeefuAqOORKSdpq3HNk9y83gPU5u24SnF2SefoxmWyQ5vodEwCDfLpqu3UQpDlldqPPHQN/nKn3ySnlwXP/G//zzf/PRfQWWNtHeA3r4CR/7yU3hacdvBG0iNZv/kJjZv2kQuk+dsaZXjM2u8fksO4eaZ7O0nkF0cOnqKLVObiJOQNLXkyajVIg1jWq0mrWaDtXqNShjYABXFENvSOm1P0Sz3rMPlSS6itDvcIeNs9JTspqIulmJCI2hnR22oAMZtnyMDwr04vdOXlxitWBOlTQLTpOB3ETqanPJwvTyNUsWSP6Ug0Sn1JKKYzeGSgIZadR0pXUS7eY8WHDn6AkODIzjFAkGzQjbnUsz6tJIUP2vH6o70cTOGnJ/B6JhIamo6IBGGNE1xREIhK/HcPCpbYHZ+hoXlMsYoCgPdmDgkNzTMlqsm6C9sQnYPojwBXg8qa3D8BKFyrNYbDPSPkBIxODJB/8RWqrn9NJLNVPJb8V3B0IHtzD70NMcefZhz51/CbndQNBocl9tuvYOfeM+P0a1jpraOMzo2xYNPPI6UDhpBV1eBob7ub5El0W3jjhtvP0C1WiUIU0s4zuZoCbjltlvJZGz2KtrX6dFvfJ3/87/9Fr/03l+4eO0uCRDGGMbHhnnLW978ys//JT2tV5Jf6Xzed7s6f9N6tXHF466YKX3twx/4gIdteKYCENKKuGk7AdDC7p2JMBiU7Rcltiket8s5t92wTtulgFKCxFiTS2MEMeB2wJnGBjJHunjZPM0kJAM8URNcaGpWhKKWajZNDDGW1cRJQFYoHjsyTaGri/n1FlkkZ5aqTJ9dImoFTIwM4sYhKjfAYNHn7oNXs7q+wokzC/TkHaYGfZww5o49m7lr9wgTfpNb9m2lPLsCQcC50nmMGeTcqSO0EhD9A/y/nL15sF3ZVeb523uf6Q7v3vtGvacn6WlWZjpHg4d0Gpx4dhmKxo3NTOECUwVFmaILqiGK6jZQHQQ0VQ2FDQUYcHV1dUeDK7ANdntIg+1M2+kcpByUSs3Tm/TGO98z7r37j33ek5S20xE+EYonnXvjSrpn77XX+ta3vm84NKRJzJ7pPWxsdMiLnBuXLtBZvELLCib2j/P5k2ucef5pqmHBM+c3WFrfZmFhntykVKxCD7d522tfz/LmGsGg4OTWiLVRil+tkRcF+/bOUo1ChNVYY8izjEwXJOmIItcMB0M6/QG94ZBRlqOtG5x22uiURpGy1D1ymtvOUmlndm1HpmRHY6lUo7TO8cTJm5SuNIrSQosyw9pZsAJK7tDOdcddR/F8RWg9BllK6Amkitw4kq+o1utUoioWiyckO3aYSMnMnv1cWr5KqDSB0Hztya8xuWcOKwUCjcotQTVgMIoJg4gkGVENqqByCm0wJicvClAeY5UqUjvHE3DcpzTL8K3ByIDOcMTSpetkcZtqyxE3N9d6XN9aY8/scQbDLcaaE4S1MXxP4ftV6vNHiAcpcVHQnNzPle2QkxuKi1tdJus+3tLz3HXoBGOtKqdOvcAD993LyadPcWCuzo++5234SYaNIrZWVqm2qhRZTBbApQvXSdMcay31SohvBHceOcLSSzAcay29bo8TR09w4fIFtjpd9h/eT7MyyYHZPTz97LPu2ywzkq2NbTY3t3jVa1/JI498ocygy+evJNJK3vA938XRI/t50xvfxGc/+8huFvSNyJVOjlg6myIDv/+nf8CnPv7Jlw0wO5/leR7GGH7iJ3+KWrXGO9/5jm8vU/KNJLdglHdLPSoopHRqgOamIYAtNIU2pPZWowE3ymkNzpYJwLifO/Q+zwoKrXf/LI3A9xXDwQCvMCAFr6nBQqXCILbMqZzGaMhTz1/k1Ncu8cXHTpOJkLNXltnXiri+PWBpbRvh1Th+aJ7uYEQxMcPS9gYzczN89ktP8LEvvsBSZ8Ra19DvSCaiALPdJt5cAy9iaXmDa50NrvYLhqMqUia09h/H+BGnnzlJ3N1CVJtcWFqkPrMHG1SIvSrPXVpky6Y8+onP8dPvezvHm03Ga3N874MnCHLJcGObi2eusr69xSNntzhzJsvLSwAAIABJREFU+gXOLQ95smfpJgWX2kPOLi/TG8X8/WNfAelR5BnGGAbDEaNRis4NWZqTD0dkcU5iNMbRvcgps34rS2zOugVUGgYIudOFu9WS25SlGaVJQMlXsnp3YWqtd8mURu/IYOA+9yUqAbnOoNAkOidUEXnqMdQZ1hYEYcTG+gqDeITCkqWaIh9CCEIYNjcu0YjgxrmLXL+xxYFDx2i1WijhoW2BDTxMZvF9nyIbEXmKfhpTJAqFIDMaKzwnkZtmSFEhQFLYmP4wAwxWBXQ3NnjkS8/wN39/gb/4iy+xcnWTzuIFEIrHv3SGtRvbzN7/LoY6YNjpY70WMqxwY3GN/qBD3O/wzNVNEiNBb5JcuszFT36ESq3C+voK0GN96TSNhTmqRUokNI98/JO8/b0/jqyGXFy6TmVPk4fe+kbWzp4j7fU4duQwtVrIje0+0XhE1KzxL3/x5/mhd7/ntu93c2ubk8+dwvM8PN9na7PLZ7/wOZ698AIT42MlzruTZUmefvppuv0B7/tnP+v2W0ms/E9//PtIT/BL/+pXGI4Snnv+RXx/5/C6vTzbVZCQAozF6hJsGbTLaYGXh6addLHhJ//p+6hVIwL/5cu/l/20ooS0nc2LA8QUjrdSaAeT7gDdBW4MSgiXJRVW4ZXa3DtYqBCghUSXG6OQThLFKJyshXD4RZomKL8s4wwUyjIfWX7mnlkemJ/lxto12v0erfEaBw7PU6k2OTw9zrmNNnFvwOtO7CFJ1nhhrc9nnrhAS3nsn2zwpx99glOXNYFfY6VjSTModEZRFMRpztbWgOtL2yx3Bpy72uHMlRUurQ353JOrLL34DFkm2dwckDZD1tfXiZOCMxeuYYWim2u2tkcsbRVsFoo//Z0Psf/oUZ45v8RKe8T+FuRDS+F5PL+0zVJsOHl9i7O9lC9e38CUu36qWsWPfKampvna00+zudEm7vdZXl7l+soq2TCmO+ozMorMakyhb/p6lYoLO0C1W5w3sxjHO7pJA0DoXS7Sre8TKGSpcbSLPZnbT9CdIPXSBTxWa5BKS+BXscqAD5HvtLWVFOydmqLiSQIlqdZrBGENMxpBHpNJwYtnnkOO1/HrIb4nyeKEOM2QwsdqjWec2mboBwitqeCjPI0nNLUqBFGI9AJMXpCJnFpNEQUhniep+B5JkbNn/zxveO2riXXKuX6H3/i9v+YD//5v2Gov8Zp3fB+Xb6yxtrFEHs0S1Saw1Wk2k4jBYESSdllb2+CpL3yBUVGwsthjfnJAY34OVWtRiJS9Bw4xNjHG6vWL4PvcfccJxmb2s/jME7zwlX/g0PwJokyyUG+xujlk4fAhLl6+hB9GRLrA8yI66+v8xZ9+hLPnTpcuMuX3j2C706Zar2FzTdEdIoTHs8+d5vvf8Tb2LexlYmLiNj+5QW/An/3Jh9khviql6G11eOD+e5HS45kXznH/6x7EGPj5n/uFrysd4Wb59tAbHtz9/Qtnnwf4pgzynfVRq1X4xX/9y4xVa1TrNfBeHuj+lnpKjoVXpnLaUDhrVRc5tXVt/XKI05ZESI3r7FhrS8+4kqldbhSXNRl86zZHZAXKGnxhCawlAvxCEwmBFoYKgtwkiGEXM9zmaixItoasdUbEvRHnzl7gaq9HvLjNzESF82ubHD3xCgZdp3V04fxZPv/UBaJQcT0fMMidDMX2aMT8/hkOzs8xf3CWqT2zTEyOoa1CWM3q9ggZTLJvYYqlpMInv/osUbPF5acWWdzs84VT14mqIatb25Bb+oOYVCnCSoOD+2c4s7LCZMsysnUG1uPGjXVG3RHPbwwZq4QsJ4YXtkb0ckqzT+iMUgajIfOzs9x57BiNySZXb6xx9cYGWZLSG40o0pxCO8Db7JRYYkdhkpeMmNx8xKK850o753TsVpx3m8qkI0ze4mQiXCNClPQCxM2MS78EIB0lfYJclYxwjS8yGlEVPLdmChGwtLrkStG8NBdIBaGOOPvlp5g7dJxzT56mHk6SZ2BUQD0IELnFr0WORyUl24MunXREvRpSDTK8CgRFTpFnSKWpRorQ0yxunEeqkEoYgLVMRVV84ZEGIwdBGEkeD5kUMb/1x3/Px//PP2Nrdci1i1fYutHFBD5GKy5dvsqLV66wudFmfWPIsWNzXHjsc1z7/J9w7ewio3jA5spVTGHJ8gENNKeffo6JGjQ9w/rKJWya8LZ3PMzMwhjba8uce+FJ7jkxztXlFQpdQL9HbXycSEu6wzZpnpBlGffff+8u6LzTRet1ulgBA5sjjAYjePzZ08xO7uGee+/Y3cBSSi5dvEYQOJXRHXJm5lkOLxxE65zPfPJTbK2uobVmFPd2A6BE4ElVriHLw+94K4cP7919vbOeojz9TVQ05W7Z9l0PPwTWJ7B693D49oMSLksS2i1JLdy4iCkMeW7QwukgOTUKiy43hSzJkZ4Ez4InBZSqlJKyE4djdfsC8CyBJ/AkKA9303MneogkE5a6hHgwZKVXcGUr5dENy9cud7m+0cOmOaGvWM00QwSJibjwwjXe+MACS0vbPN2O+NqqpjERcN/MGMePT+E1ahw4eoLZvQe4vNlmrFYnbNYRYcgwKQhbU+ybm6BSsQgVktYtiSmoGMmTK21EPOLAdIOVnuGxC9ucv7bGqMg4/dxlTp1d5sXLS1RCxXo/4dyLl3l2ucs1k7FiIlZHmnPtITdGFhGUVjfCeeaFvsD3Qi5dvcrTz5/h0a+d4sLVJYajEWlWcHFljcsrG2x0tvE8v3QsEQhbBv8ye/1GHRK740wiLbY0mXT3c7Cy9INjd4xkZ2FJUVouWQVWY803Xza1QuB5kBcDdJ6jZECuC+pR1ZlI+gFHDuxHG4mnE7IkI28ovvTMl9l759346YDXvvUhRpttvFaAyVJsNUB7ATL1SFROWKnheSGTzTqaHJ0HVLBMBjGNQDLuGSomoxblDNcLtm+s48uCSqWCPzbGZj/l8587i8Dn7ijg/ZUxnu9lXF1c4rFnr/G1p57l9IVLhHsmOHltyBMnn+XZU8+Q5wVf+IdTjE/M0Ky22Dc3wdULV6iGkssXLuK1pvB9TdzNWOulLD37JD/6wz/C2Ljit3/3T2iP+sxPzLJ17iS1VgSBh0409+yrMx9WOXjwIG95y0M8+F2vp7vVp+aHLF1Z5NlTz+0+FzeMXfrdGWcSsdNlvfDiBU4/c4rl5ZXb3vOpT32KNE1vUyJI1ra559X3A7C1sc3/9hu/iRCCj3zkI/zgu3/ESQzXqmjrcODvfvA1vP5Vd3Hi+L27a+ujH/87dO47/tpLA4swYAXHjh3h6MIJkmyAqVRJkRy76/jLxpyXDVm6ZPk6ATZ3SiohENqxtXfkbKGMpQpCA6kE6QhNoEAKB45K5VjdSggk1gGY5QhLYa0LXuVRL5Vy1kxJwZjy2BoVWGVZigtOVH0e6eQukG33qCU5/e2MmWqDq5fXOb4wRzgW8KGPPUXfg0aR80v/+BV8/plr7D9yF//3P3yV6clp5g9oziy12TMzQXswwqsEbPUyqpWAUZoQ+yFT05MsnT9Hdc80tQbcSHO+49g0Z5c6PLHe58R4hVcfnaHf7tA1IGsWE03y5GKfJ688Q70KeyoRK6OEA9UqJ9c2CYCpVpPFdhclFMr3nLCZcdwdJZ2LxXA0Ii1ylAyp1AM6gxFJliCEohIFFGmKJ500CVCOM9zslohdLZ8dkbCSV7RD29jpmhqvdCmRZcFejp1gHHfpFrrADrjtSoGvD36p8KmFATkemJxqEDj/OekjrcOv0iJjZfkG+w7vo1K1PHfqWWaO7WXQ3SSoCOL2iMsvvMD42Cx3vu5ONrbWiRComofoa+J4SD2skMYdxuotVCDxZUy9UaHTLpCMWJidZKVzmf1hwN8/v8zJ56+ihSxxXlNuHPjZapVOseOFZ5iYn+XktevMnZhFC48nvvg41ZriO9/8Y1x44stMHjlKpj2UH3Ls2EHe/kPvIskz7n/FCYrlqyzH28hum1DmRFM19t57H9c+epoiXMM3Ay5eeIE77r6Lq5cWaQaK1VqEHh9nff00Ju/hBwHFoM+9r3s1zz93ka3NdawUu864bjrCuy072Sm3xppNdJGwvLy8W77dmh3dek20JrBCceedJ3jxxXNgdbleLBPjTQ4dPMAb3/BGnjr5DHfefQ/H7zpIf22Njt+9uW6EQkjNN/S2tIog9Hjjmx7GCMnYWJVACryKplKpvFzY+VZjJmUqJSgxj1Jt0nOi9QUuK7Ll0Kbn/i2uLMPRB9w/XrBTz3qeY1TK8h6+03fwKE0IhGRseoLO+qab4ZIKS4EfAAR832TGYq5oeJIglEx4AXoMjkzWOLl1jcMHZjm/eIOhrEMQcMfeWfbPV/n7SylPXx/y1NWTPHTHIa5dXUWnPqeuXOKOPXXe/PAb+du/+wyvfPWr2Ni6ii/qbG0s8fo3Pswn04z3/sh7+M+f+CJBb5tPfO089x6b4V5fsNyN+avnNpmse1RsjtU5++WQuw42OX+uT5pX+HI/o+aHnN5KiGoRyTCh3R9iLTRbTbbb2wSRMwNQiJLdbvB952gR+IrC4LhI0qXURVFglfNCI3A22xaLNGKXXuHKM2eF5GDvHGHdBtQ2R8pSK0makt/ELrZkS4x8xyzRLURR4lY31SxfKocr/YwkFYxFkiwSpG7QjSK36DBAaMhSmDu0l+HqOtvtDrPzc8hCkEcCkxuCSPKm172TPfcd4fkXniC0Hn7To93eJpA+olpFJH2O7D1CNQjp6x5qaxnby7BDTRBAd7GLTHJqlYx33BVyfjFk/0zAly4NSoednD9ujVMTlqsm5buCKqdExoHmFAfn5llbafOHv/uH/PhP/BOeevoJVm+cI1cZ040J9i4cZt+Ro2wtrrBncoobTz/HcJRy5xteib8ZsVZsUwmrZHkHmQ+ZaDYYbW7y7p/6Jb7wib9C6oC83ye8c4HJRpU0DHnV8QNUx6fwsIwdnGK826M/2CpjqMCWjkLj4+O02+2v0zcSQpCMYrIi59jRBS5cvOaaTcbsvn6rauipM2c5e+ZFVlfXdkv2nfd+5rN/y4+9+4eYnV3gwx/+ME+feuobUgOyLCn5U7c8/5JPZdC8/1/8G6yXIIHIC5Ay5eih46hv4ZDyspSAR//wNz8glUSW0UliUBYCCVJafPd9oaRAlOC8lRAJidjBOqSz4rM71kvOCxdPunawJ9z98ttyWktJirGWxLqRla7B4Us+aA3tkebF2IHpK/0Re0KYXRjnyPw0KxtdnrrRo9maZCMbcL0/5NnLm/T7OVvDlLAiSEeawxMhzyzFrPY79Dd7ZKZg38FDNFrTtJe3+PyTz9OoNxl2O8xMNXn85ItMhpYnT1/kO+87ytmr1x1vKfDpZjnDXNMd5WwVhoudguNNj++48zD9rQFPdVI2RhnSs+RaoHwPTxhQingUMzUzjclStBVIJfGlR1oUCOEhPYEpoDA5woAKFEp5IBXCWpIixxMexhqsdOU1ZZvf7mBApaCbFK49brHulDO+69wJv5xpvGXOSlm0djpHO1kyu1nU7lYAxG2n8LG7XkEQRuz4xHnCQ2pLNVLkaYrVklpV8tRXvoIxHkFtHKsTan4VhglpllCtT7Adb/PR//KXvPLBh4jzAWaU09eWZiVCpBmHjx0F36DTHJGP8Ipt4jQiGqTkWtOseUSiichSJvf63LW/wWi9YO+CohMbxusRb9Fu3GWf9NkGFtOY82vrBNpy5soSG90+9951lGMHj5GNYg4dPcK10y8yOTPDgSMHuL54kXw0YOBLTFUyU5H4XsRTX3mSYw+c4PjBQ2hTMHdwgXC8SdHrcezeB8BYJidr9C4+xfWtFZqNae593asYbi2xdPUKveUVXvXmh3n0M19CBNGuKSfcVBDYCUhBEOzKlkxMtDDAvulZ4iwhTYvbOJgHDx6k3+/zq7/6b9B5yqc/8zmMcfOTtwatbn/Ao1/+Cg8+/D088oXPYvU3H9x12/bWoW9LGPr88/f9An7FJwhCokpEJZIcOXbMrQsBd99977dJnhQWZQ0STWg1oQW/tNfxpEAoN9HvbJJcF04aSy4sRjkMSuryRDXOMNBgEEBm3BxVqi25dcGmMIJUQ1wY0lJa11iIpHTGmJm7MT8mmapo0jRGBTU+s5YQ5ZbHT63QMYpqdZwnbqywsp1iE02ajegO2njK0FQeVZHRnN/P2mgLRMbkbIthp8fHP/5ZHnv0a/hz0xycqbPVH7K1PWR7O6XdHbI5LJAqIIn7oDWm4tNNJeNBgCw01vcwGsJAsLYxQBNSaURYaalVPJSQeGjSJGOYugzIDwSbG+vEWQ5Wo1BoNEEYYhCkeYbwBJHvgfTACIqioMgN3aEDaxNT4PshgRUoVZZuCuDWiX5TDubq3cduyHfvA6U2s3u/0e653vr+m1mR5JstHSsFWZGjAkMgBUanGGAwGKALiVUjHvvSF1k4dpT6VJOoHiLw6Pc6pGQ0Gg20yYiigLf+8PdRiSTFsI8f+TSiKnmec/TIYYokxaiQuBiRxCsoJRgN2hgPxv0KNhHccUCz93Cdqco4k/sCHnhdE7OumOxlHOsXSCCgzPBlykG/Sih9Lm2v0QgqCARZVlBpVchtzrNffRx8TWO6SZbkiKJAak2rOcaeVpVYa66vXWPhwBQq3qTVnKLIh+R5TiNqYLI2G6urHL37DqKGZGrPDE1Rx0MTd29Q3zPP1MwYtT2TbF1f4U0P30+WF7Ra9d0SLU3TXcMBKSVZlu0GhvXtbeJhQk5Ot9OlUfN2s1pw0iVaW7I0JqxFrvFQFLcpXwJlyx90HOO9xJb96563tbu/dq5f//UPUB1z8sDSi/CVx6GjRzHWogKF8V4eyn7ZV+0OkF1GQitwrrjWOscJK8jLMGOMRXrOSdVoJ9ZVALm15NZiLEjrrJR04RZ/YSyZseRWMDKQFA5gzQpXPmRICgS5tmTl32mFxGjBg5FEBpKpKvhAIRV33TFHpxOj04RmJKl7gq7RzNUnkJ7g8EQTaQQTs7M8fupZsJLJSgUV1Gm3U8ZnZ1htL7Fy+RLVUJLLgq+ev8rGoEteq7G6vsbsvjkuL7dRXoiXjYiImQnheDOiJQVjYUQFQWp8/vqJZ1jZWKclBRhNI/CI8xJsxH0HTrbCUS0iz8cIw2iUUIkifA9MUaos+IooCpDC4Qlx0sfzRVk/W2ezXIkIPA9V2hApT3wdlrDj67bDObtVBM4tMl0usJ2yT968twuO73zmzYC2c3mepOVXyTNNmhlyo5GeosAj7a9y6cIVDhw6jo5TTAaD7U2UKMgtVOo1slFMMRpQ5D3Sds5H//L/4efe/8sgBLN7x1nYtx+DdsYJ6x3S3nX2RJJ6pY70fIRvGFCgfMmlizFf/ew6tYbPuad6DEZD7j2mePD+Bj9YreALibQQ+IIHgogxMkKbM1udoJ0PmazXSQkYdBNuXFpE1SpMTewnjYesbW0y2tigEDGm12VqbIZYhuyt17n/1Q9z4hUP4s2M4+kAXwZonZNlIfXxJlfOPI0nfcLGOFUVsn+6SiOT7Bmf5DX3PcRb3/k2ZudmaIiM733zfbzlrW8HKVxzCKc0CbfoLklBq16hXqlw5+ETVJI+x+amOLZ3AhFUbpMo8TzJ7/2HP6C7tg5SfEO8Sbq5Ij7wm/8rxTfLkgQoGbrg6EwgmRyf4F/8q39NfxBjI0O1GiEMHDl+iJHJXAzJvhEAdfv1skFpZ76zEJZYW3IhGGqNNILUlsYC1iO3kFrICktuDLmGgTHYQpBaQaxdwMmtJEGSAbG1ZCisUeTakSxz4ZQCUgGxdgPAxgNlyo6ShUzD0BSMhCQ2hl6smZ1ucGVjwHiomVWGSqXCibACVnOwWUGLIa2xiCwXNFsRGytrbBWCVq2CzSX9zVVik3K93WNmco72Zh+pIsaDOqbIeerKKmfOvsiV1TanLi8zUfUZWhihmKtXKUzG4jDmxJRPyxrmawFLheVIvYqIpllPNEVqCSpjlE1HhFCMRgmjOHeqCsoySjVpoanXGk67RigiP8CXglw7kLharRL5EVEUYrVFF7aMSwJhNNLzqQQ+O9phopQ8cRo8AmPdybpzsu2Ap8YWu4DljmnATjCSO9lWabkkMCVTxAn43XpF1ifzwfiR460R4KM598LX6MQxs80JhLRoqxjmKdWxOrl20GasFV49wFrBZL3F2JTlu9/xJj763/6CVrVOBYGQhjjP0Fhaqs3eBuikYNhNqAQCOYLJes01DGrwzvccZXNzgMksvS1Nc7rG3gMhDekRAAKHZzat4G4/4pj0+aEffSf/8qd/jNd+52Feef9xOsuLVCYjJmt1jj94D2kyYHD9DDSr5Ilm5sB+0iynriwTszNcuLYI0lBFkeebGJtTG5+DUGJ620xP74ckId9eZO/+Kvc//B6CcUmtViOaajJa6jExPcHr3/RONs+v8rmPfQqrzdcZf+6qWlowQnLfA/czPl3hLe/5cb7/f3w7F65tsDDdwLeO51SphHzgA7/Kh//433PXPUf57d/+rW/Ypf1Gc3C3XWWX90P/+T+hwgChLaHy+ZV/9+sEoYe2gkYwhrEF97/yOEpIQuvjSR8pJf63yL5enjxZdmsSa0v2tkRrSIUjUOYaTO7E/20hyAvItCvBrBYk2pIYQ2Hc+EhWFKTaoIV0myQv3ElqnJ6PLgw5xkkElGRKm7uSTykHqEklWDOSa8OMkJC2ydlo9zm/uM7Keo/5A2NAAlIw26jz2plJJvDoDzJGMuHqao/FOHFyGUnMVpbQHRZc39hkoR5xfW2Tp9a3SPwxJhs+R+ZadAaaug1oxzGhHnC5mzERelSkYSrymK1P0JKCQ40qQ+VztT2kEBl1qfjS+jYt32dMwuLWFko6Q8kwkHiexPcVYRC4Daxc4pPnOd1u24nqA2mhGQwGxHFMlhUl6Hkz07K+wpOKNCuI0wQrxS7g6Epn635ZvTvz5hZ0KWuinHaO76AqPCUIlCQIFWEkCQJFteJRq4ZUq1Va9Trj9YipRpPJZvP2NWMyEp1DXuB7EcJmfP7L/x+11hRepUKCk0oOpUeoJKNkSFFk1GoVTDrAZDHjrQZBw8dkIJRmq91GCEsqJFlhSJKcPU2I4mWKbkpU8cB66LzA8zz6w02aNU2yNeLMyQ3W1yXGJCxeH4Fski1nSGEIlXQ2U4WhriV7Edx79zGeefIZAhMQWJ+zz51j+thh6kgWXv1K2hs3iJRlc5Sycv0a29sdGmNN6pM1zjz+OUajhImxEGUh64+oVabcgHGhSId9pF9na9THkhGMNWjMz3HpqU8ThU2qY1NE2iOs1dm3Z47llVUeeOU4gzxB7YC25bUDYtcqVQ4fmGc0TBitraBlxle//AVWbnTZN1Hh6vI2uTT8we//73zoQ/8HTz5xkvf9/L8Dv8Kv/E//89eRJMEFu5cjRGIdMnn9yjK/9x//A9oa0tx1VD0svq/wlOXA/oPEo8RJHJdTIZ7nfUsi0ssbBxhIS7p6bg1WG5QRZGVHRpeRWzlaHbk2yFLYXngSaw1YbraOS/b3Dghulds4GeV4RBmgPWsRhl1hez9w3nOegJG17MVysAnXNg2jwqALy5NtjRckTImcZqXGVqfLHbN1TJLRH7l6sIgLoopiGGtSnaLCiPlGg2vbHRI8tlY7LEw0mAnrpJni81eWOT4/SyC6XOxmTNQDrg9GPDg/xcZWj9CAyHNaVY+pw3up6IyVwZD5us9rp6b4fy+uUvclQ2HJjCzBRMf78ASglNOQKgooux81P8QIiMIGw8E2g+EI31dI6eGHijgeUtgUUbhSWXlO80h5gonqOMN0RJGnzjY79JxCAzeBSCUkQngIJfCFdOqiSrkmhu8jzY4SojOyVEo57NC6BSUkeMK97pVM4+X17ZtrpkgJdISVHrWK5fOf/zIn7rkf1Tf04xisR61WIR728fwxfM+jMAk291BexKHDC/Q6fbaHmtlKgyRPmNw3h/ICsqQg8GPGxIDO5iJqJNnuaObJmG7UaVY9bqzHjKmI6VoFsVcx6AuubW2SbhXkI8nFC1eYs6AKXNbqlyUqlmkvIri4hF2YJkn7rJw/j2xOUSRdjhw8TEWnyChCyxBkj/GxKSrTIbVAstFPmJw9QHNqD9XKtiO1Jn1URVCr1Xjm0U8wOdMgR7pOs1DEVQ+/t4ZszjG1/z7yusSLJ9GVmCy3zB86RK1iyDlPLfIZpiOUkGhriDyfVBusMFxZ3QCds7BvjnY64stfeJI3vuNNLK72OTg7zXc89Hre/4u/fNve/re/+lsIKZFCfJ1K5Xvf+17+9m//9jb9pNu6fRKmxzyeeeokc+vTgOSXfukXqdVCAj9CSTh4cB9GekgPhBYY6w4Ma83N6v/bCkplEHXaXk6i1srSzcRadmhF4MwjZYllSE/sdmxkKZlhoez03ET5dW52BA53X1e4CBV4LmhFWKwnCbQll4LACiqe5NGeh1SpgymVwfcVj691mW1U2RsJBjrjFScOcubMRfaO+WwMcjKpKKzEBgFF6vzu10YJaa5JLYRhyCCJWU9yzp05w73jNZ6/vERUH2Na5NR1TqvR4GvXN5iuSiZDjyEFIk3ZvLFGMDdH5CnunWnw9EYboXzwBHmSl10Qu8uWTnFgtMDxTrQtnL1SlhJ4kt5wiyTOGKtXXbCq1dCFJZMDdKbxpEcgHYXAD3wKIx1A7vsEviKUAYFfTsl7Hkjp3IlReNKglEKVGZXyPCqeQqkdxrBFCc8RWYVbuJ6QCM8RPT0h8ZXnZIsR8NzF3TWjtaZoBlx77ilqtQr7Dp1A5VCEgqRbMN2K6A66VKMaFQE6UExUZvCbERUZkKYjLBm1wkdHCj8M6HZGNCc8JDnZsE0oU/obHXpdgdcvSJsVepUeZqRpjkka0zWSgWX24DgXznUItWGiMc5GkLJ4oc8eVYEwQFktPEkaAAAgAElEQVSQ2k0VODKpYG8lYntqL8Pz53jNd7+KR0+9gJ7bx9h0iwcOPoQMQm6cf5EgTxmanH37j9Jvt6k2xjh+7yu5dPZ5Dh6aJwh9sBV0kdIfdNkzsw/hKwrTx8sTwom9cOY80yceZn35RaYWjjDs9igakrQIUCKBYZfV5Q4/+H0P8N8//RQ/8I/ezic/+XnwJXmhqY3XOTw1w9lrl4i8gI1Byne/9rsY9ydYW1smFpBLxcc+9ndfRyHYAafNbZQPd/35n/85Sil830drzcLCAleuXNl9XRiYnD7M237graRJzq/9zq9TSSKkMghZcOzYUayReNIijMIIdzBqhyGUXeBvMyhJAUpJRGGwJcnRkfKcAoBwaxbjxJOILGhhyKwtaQI31QCstU6OAtehcT8tnhWkpYSrLEXe8J3QWFVpfCWxwiADQWgFca4ZJCEnh7lzRPHUzS9VSVr1JiujASsjQaMasrfeQMZtWvNVRoXk6bUec5FiKANsPkDJiGboY3VA1YcxIVnVMdpCFlSZqhcEnmVUQFMoGhXwbUS7SLFGorTm9OaAt7ziII9f2ea+8YBTax1ujDSRUsRZqUvuCQrtFsHOAgk8J74vpcRqgfKUcxLBUomq1PwQXR4sSvoMkx4Cj0oQuPk2dtjzAulLBApFQW4FXqAgL1iYbuyS1QLPdziQ5+GXxEqlFKGSWE8SCoGQnuNCCYlR7lDxhNPullLiSd8ZP6DK0u/2Y896VRZPP8P41LT7f+URJh2QFJpWo06v10MQIXRBgsvW9ixMEuc5QgZUxiLyOEPUqkRBhCkE9aqm5ddYZ4gshmx2N8ljw1gg2DI5vX7MZGDY6lp84bCXmYmQyy+sIUTE3N4pOhsJQVLQTwK8isPKcgTSUa8w2pALQZBp7OYqg6TDq975Vv7hS48zaFVp+h6ra1eIqtPkusQyF/YysWcv5xcXqVZCpK945XfcR280Ik/6jqWfK8JAY2WM79coRgmFETRaYwxSw1iqMUVKvzeiPh7R70vm5ue4eOEMzZkG+lSbuUoVUcDrX/sa/uZTn8bLnV6+ZzXXFlepSR8hFH5ecPL8SfqjDosrGwg/YPXG+u7w9K3Xrfyll5oI3DqILYTgodd/921ByQq4tHyVoAJ7WvuQNwr6cYrOc46fOFrKrDj6iJAWD+WSGOnW6Le6XjYoRZ4Abch8Z5HkiTI1khbf3JzD0VqjcZ05oQ2+XzrkWotUisIajBWIEnCV1lIKAGCFQFrrOjSFJlSKUGuU7zAPbZ2ziSosQ+tMFj/RlvyziTp/tpZgdIIXRg5H0YI4HhLUQuy2z/LKOrPzexgozVLHMFsZclfNpyZzVoTh/madC7FibmKcJ1bWWB3AnbN1Xlffw1dX1zl7Y4uaEswECZaAWPjMT3vYULK1YZkZCzm91kNWBJ+9doPr7QQD+NIjUD6NRp317TZKiVI+pHDpt9YlPCCJkxwhnA52KCArUkLPZ7PXoRKGaCOoRyH9QZskTQmjiEynKKWIlI8xUBQGIwqUDTE2Z5Sl5LlmT7PO9HiL8YkGSoBSPp5wIPutmIHvh0iRYwnwlEUqNzDpCYMlQCo3l4f1SmsmBw4r4X0dKHryyUc4eHTB4UTVFskwdWB4rhmJhFo0iUEj0gLrpUzM7GW712OmOY4pLEWS4kUh1Xodnbmuoy4Kljs9QiEw+QTjs008/wrxDc3RIzWMtMh6HTFK8DJBb6OHjTV5YemNRphYEOSCXidGK0lHhGAFA2PwhUAqiy8CrMgZ86B2/QbsmaE1O8/bfuAdPPbJx7AVie4XGDMkJ+Pw4cNUGhOMtxp4nk8QZETj+6ig6Q6H6LwgqDQYJQMoIDcZigremGRmbpbt9TMsfOd7WT39f9Gc/05max7LvYLNa0/S6x1gT63F+cVF9h4ImJveT/DfFY8/9igf++iH+Pl3vZ93/fD/wLWVDa52N+iubJCiGZ+Y4rmTJ+kayfZ25xsC1kKAEB7/6G2v5rsffojf+M0PMhy5slpKZ5VmcXv3Pe/+UfbP7aU76t3+GRZ+9md+gp977/v5yH/9U84uL3NofB8HFhZ2TRCkijBlx81hNXJ37tJ8C/+4l8+jABlKAmEINRjhFqcxO1lNSeDynImksQXW9/FwnR8lFLnV7jUMaEfPy0vJE1uWMgWCItUgBXHu5FL9zEXbQDpQ3bcCXcAWPvdGmv/SG4AUBDYsy0UwZfl4pNLiEut84cIKE+Mpb7vnGPPdDpvLbe6utdk2Eav9mGA65MT4GO1+nzCqUYxiPrfU5d6xEX4geKBR4zULC/zXM5c46PtM1DzMwNA2AxIj+OLVmFo9YLUzKtnSpbCacC62STwsWdGWXOcodXPQVSCR1hAGHlnuXCyS2EVqYws8pchyQ2NsjNFgSKoLhPTQRUZeGGr1OlHgM4xHFAbCMCLwJHHsAkZaDNlOPKIoYrzeIPB8vEDt4kAYdxAIYZ2ag6w6mVuvHE8oS01bYk7YvDzlJAiFKkdGdvSZdq6Dx49j4ozQt2xvrVOtVunFfUKvRrRj4y0E/piHygLGImcSEOcF060615dvMIwF45MzZKMBDAUirGFHMVmWEzYibL5JtjViak+VUVszjCEJYgKl6W2neFFA6IVgagwH60wIyx33znL5Ux32jPn0GzW2uyNCKyiUR2QVQ5sjgKqV3O0JziZD+ptL+HnKPa96BZFWaHJWFpeYmGkSjo0RjVVYurxEu71EEDSppgWxLfCVR3P+EGl7g6Ia4IsqWSHwAkk1rDDKR/STKo2pmHrrTuYOLRBLQ//aaZJOm60bBWOvupdR7wa5Nw5+lcTkLL1wngsvLnH0lXOMHZlhn+9TXIvZ1wp4xSvu4fnz57m80d3tyn2jy81HFrz17W8CUeGeO+/i1POnydOMRqPJ+37mn/BH//GPGFLw1x/9b3iex5vf/NbbeLMW+OAH/wIpJT/1kz/L3Xed4MCP/SRbG9u0JppQ9wmMLru2lAeZLEm9AvMSXfevizkv92LgWQJlHGEyEPjeTXkRLR3OhFKkGhINiRX0C81QCwYGNrSlXwiGmaSXKbqZYCu1tBNLJ5e0U9jMYSOzbBWC9RRupJbVDFYSxWIMV0ZwfQCX+4oLI8FaP+OMVdRMSUps1REGTKpRheDiRodY59y1sI/ntnIeO7dEqguiSsCxg5P4niSoVHnNsXmaEo5MK/btm+L81gBlcuaqDURQYW9Y5cW1Hh984nkCKdnMY073enRtlWsdQZLGVKoBq/0Yi3IzbMpNxxvtgMFCO34WYkcf+ebDsOUEtzEG35P4ntzF4KT0UJ6HrwKGwyGZ0VQDhxUV2lko9eMBgyxzygtoknxIt9t2IrWBjy8CsiRlaaNPEEQ0G3VajSq1SkQ1CqlW3c9KGFGphIRhSBQFBJ4iCFwwC0LPucF44AcBQegRhJJAaZRnS+Ls7e3dQCjiTJNpQas1Tme7QxCFTpdLKvwAGo0GlVqN+SNHiOOYJI6JRwPOXb7OIM5pTTXJ85S8SNnuboHQ7N87TzhRJTIe0vOZ3F9lZnqMetVy8HCFRsUnkoJKqFA1j6w35Nr6FmqgkM0qp55rMz/fRNYFquo0gFLpURhNbg1yR4ZHShrSp+h0SDp91rdWCYocXYwY9ntUg4B61MAUOaYoSAabTE+PkaaCON7CU86RxFhLtdkEESGrYxgFoYpQ1SqDvqA1NoHQGdVak7jdo1YNSOItTJ4xPlZnYmKKsVaT9Usdqt4E98zsZ3V9ie7qCsdnZqA74rlTT7C4dYmZ6b3s2TNNur5MNVDfkHu0u+4s/O7v/DpGhNTGGnz/u76Hu+8+zK/92i9QrUbc/8oH+LGf/lk86UjPRWH49Gc+xfd+3ztvCWwKKQKn+GHhyosXwVekhWY4HDIa9dE785jSZd07qqbWavxvkQu97KsDqzCpBemGPcHJkhjrRL70zhyUcaJtxhiMVBS5oZCybO9LMlFQaEGuRZkluU1ZGElsJIWEwjibSiHc/JPEmVdqITHaIeC5UFgVcGNYICS0KnX6vTZG+RSmIJROZ+fk8ioPHj5I0hpDF5KFhROcOvVVLq22WU49vv/1r0NvbjDTzHj62UucXo+phD5JkrEy6rM8suwkAGNC0BkOMBq0VBzsrPA7//YX+fRjn+avvnLRaVlb7RQ5laBaCSm0pupX6Cd9BHIXVCx9Ot3mVYosK8oOpizvOYlR31e45pwizy3WUxTCkI5iLBJtJdYWjEYjR14sP1soiS0ZupS0jcXtHkiFH0oC6VMojS8khXXIkLUWLQSB52YblXIdO6zDAgosgVRIBMaTyHJo2OFFmZu9u+Xajg1SSCp+yNp6h2qlhhI+whRMz01hpEerXmMYp6yvrzM/02JlK0EIw/TsHkZZH+X5dDodomqNaLJKtRZxaekK9eoYlUaV8889ztG9EYPegEorxE9TCHyQlrF6SKJ9hgNQWcpAjdDbNeqpJpySbG8bemmH2K+RJgV7PY/EOK6XLx0ZOEAwZyxrj3yRbjXhjtd8D3lhqVhD0llDT43T722T55rO9hpkkJicIIT22iqVsTGsFxLIkEBCJWhBnmIY0Ru2uf7MWRp79jE5NUO9USdojDHKDUrlNJtzHLnzIbZWLjNKR5w98wSDYcY/fd/3cm5xk2a14Nn2NsPnn2TPwWP0X7zIcHWV/K67qe89Rvz82jfdzztGApkO+bPf/zBXr17fXZv33fcgq6tr/Nw/fz+9Xu8WSolbsG9+45v4zCc/Q64LrNXokjSrgaHRhLUQrwjITKnxlBiqrTrSd4E/8D20dtSenQHybysorQ0cSCuULLW1dwTdHGhrSyVDa4VzOpHKESm1G//MrCv1cqHIrXR8Jev0lwsDWEVRMjS1sBjr5uGU8TDoMgBaV8qkbrNFgXCtTCmJSweKHXdepQI0hnSU88iZs9wxMclGPuK9f/CX/Na7X890qFgcWGZmG3zi2VP8Lw/9Y/7or5+kX/fQcU4UBRRFQV5YplstplpNup0t5moVLq1v8WYpOFpYBp2U2Ucv0TWFG0wu5VuMFYziFE8qOlmf6Ylx1rfbYB3InOvCDclaTW7B9z1kkSOVJM8LcqvQaYanS9lRm7kuiBQUcUYYVoiTBLD4KsDzwfOqgPO1U8oHMucWYV1XqTcc8OT5S7zh7hME4xERLiBJKxHSY8cBVwqQUu1mb0Lc9O4z0s0setJ5kzkyghOseynPxctykt6AvNagVnXLq8g1RhQIWcUjIckyhsM+0+Pj9EYj9jabhONNht02ygsoRolbN4kh8jU3VrYIg4BmKEnCAdN7F8hNxw2vViW+p+n2U2phwPZWTOFnbCc5C/tbPP+CQhvB1Z5hJnKKnBUs54ZDjimfBOPcfIWbw5TaMvItB8IxXnhxkeCucXqbm1jPstrbYt93PMAwADkaIHxFhiHyA2y/QzKCOM2wwRDdXmZifAGtNe2NCzQn5thev8zm4mWmDh7C5ppMFlglIdaO9pJmNMZbyLpgsLJO1WTceedD9PU6H/rDj/Dmd70DvBo5KY1ohoXj+2lVBCtXrvDI5x7lH77yBOw4GttbJjFueUZpmvJrv/rvbnvOAB/5yEew1rpGxEuyXyklH/zgH5VKErf7/e189ky1zsp6j0og8aOIzGhCbbGeLcdiHI2k0BrvW5havmxQWs9cyzlLnUBzboWbU8MJtrlC0wWSwrqxEmshN8pxj2yp1W1ddNLWmU0aLZ2QYZkuayyyMEBpzyRu6vo4nSaH+IuSaazKTMD3QihScgNCBqSFJs8ciBz6FS61u1QCQWQk7V6OTXL2+yHNcJzzqxt87oWzNFp1znX6TkYlyfB9hf//k/bm0ZJdd33vZ0/nnJrrzlNP6m6ppVa3RssYDwEPkGAMmBDihwkQk2AceMwvODEYbGMIjyEBHg+bOQQQ8IgxNp6NwZbAtmQNVkvqllo9D/f2nW/dms60984fu+7VZMvrhbNWr15ddav61ql9fue3v7/voCVrnS1WtrfAwcxWj83XfB2P3PcP5FlJsm+a7xEWpMYKB9ZTS2L6aaD/ly6YWa1ubNKu14LoEY9LR18qAmcdTkhircmtIxoZXwnCCD7gOCPqhLW78c/aSGzpsS5DlFXyfECWFxgThUWIo7R5SAXxjsFgwPL6Fj1vmYZgTyJ3Fqrf9V2WWo4wsWf+CXe02CtKtTMxDa4OjhH37DmJh854Bt0hSWOI1g5tDFIamu0muStpRIb+MGSbrW520NIzXq/S7/eJvKWznWISRaUWM9YaY23xCp6StmnjkNz39w+RrQ64/QaDrBk2LzluOjRGmww38AhZEMmEYjDk6mKXXjpgkEqSqEZL1WjsjTj10CpWF+RCh8mv9EQjwzsvw5QXBQuVmLF4iquPn6J29CBIS9HrEJcGVa2xvbWF8GFwUfa7pM5ihwXdMqWmHIP+NlG9QWfjAs2pvUxNz9Jdu8Lq5WtMzYzBMIeqI88HrNd6yAgq7YT1xQsUJWjleenrvp4Ljz/Fp/72BCBZK3tk6w1e+oZ/zuknHmJuosAVE9xz7ymkeo4536jTMcZQluWzJr/Bg/1pJ0rn3K4lynO1bFJKzp07hzFmV2v33BCC1cVrqGoLIYLA1wEmTUmSCIGktD5YGCn5vFiu5x4v6BLwrnf//DtWClhDsZJL1qxhrVRsOMFaodgsBVtWslbCRq7pFJKN0tPxMCw8vdLTc46yFAwJWrfMhRG/3+HteJC7vsAipJgI0CKwlDUhmjqSnnpSw+lgk9tPh6S5xeExQoBwows5mMyXomQsiujagqkoYn99nI+deoI7jx2iMBHnLl3g/Z89ydu/5zV84OGnwEsiA0XhkDv7XwcKTQ+QFy/STHPujyN+4JP3kFsbfoBRCmxR4BMBJexsx7z3pHlBXlqSOAp+SW5Er4gUsdaULniYWx/4RAqHk0EIbVREaQukECRxjESRlmkgvJUC5yzOhbRZreQofdgGfGQ0si9dQSWJefXxm6k1EjweozSxVERS4ZWkIlTItNfhnAdX0UCElUqFG4gWREKHRUWQnhitMFLyV5++f3fN7J2eIht0aI+1QRmmG+M4V1CtTbC2eR5KjUAhtKRWrVBpT4BUeCcxcURrYgpPSWQd650tnBI0GlU20w3y7jWun60w2+gTRxGxMhTDlNgp6sqRS0FtpkGe9vBas7lUYirg8oLSaeYOxZx9eJ3lwQCMYr+sUHhHgScS4XwKKYgLRyQU40JT3eziV3qsbvSIooxenrJy6QJT+65jbekSZBZXpiTj05Quo8yKsL7rkwgVcf7MKchSsryDLKCT9pmenUdbiTVVcALrhhhfQNFh740vo+zlFHaD1c0OrD/Fi7/mdRy8cQ+/+p4/YnVxm0MLMZ978PMsLw+Zn54lac5x21e/gs/c+7ldVwAhBK9+9au5fPkyb3rTm3j44Yd3O5zgsRRu/DsF6ZnWJTuv373RjKRIC3v2cfjQAQ4dOszly5d3n3/7z/4Mb//Zd/D6b37tyOpI4JGBQqQgNmYkEA9NjlBw5IabvqxLwAt2Sktp6ExK74I3N+Wu+kYKsUugDBTAYH+ADEzgnQ8vvUMqiWbnLm1RIgCNgW3MaAsRLuaAvRh2eBVKyMDzwZBEkOceV5Z4p/DkCKExcYQbDPFeBltXZZhUhpXhgFkNb7zrNsxYwtlHPHf/4ymO71lhbm6BBy6t8/dfPEMridge5AhpQJRBBCvCZ7CjmKLfl475N7yOd9/9Iewzz5qXgekuoKUS0qonEYJunlOOPg/e0+sN8KMvW44A4syWNCp1esNtJILSl4EfZCEXUNg0GMQrybAoEViEkJSFCxiWVEgZhW2VDIr+SMdYWyB14IDlOWx2+2wPM5qtBBOMqXAjTVxEkC8IpahIReEskdKjDnb0XfsQ3eSVJHGQG0NU+BEe9pztm3ZsFznXSUPfOzZsSpEOqVZ7jMdjDIsht996G2U6xEuFcH2kM8FmOZGIXo/t1VWywjExuxfpM6baNS6cOYvLN8j9kMRH5Cql2ZDML0zQijzzkw3Wt7fY2BogC0PaydizHz5/rsRbqOge2XCcq8OUCMFWmfNFu8mdUT3YwAgQUqK8wGmBFZZIeIz3tLRgZnGD4aFxKnmF5aWTnH3gPqrj0/T9U0w0D7D0xBdozRxkfeMaL33Nd3P18U8ysAnV8QVWTj5ItrjO0Ruvx/QFZ6+eZO7gXrKNLdJmi7npNp2r57nuhqNcefAekhb01obcdtNL6ec9NlYvUffrZAPoDjP+8tMXePt//vdMHjjC2//ju1jYv4+TJ0/vTkK11nz0Q3/Jpcvnueslx/mln/915hbmWVpaeh4AvkOo/HKe3LBTuCA2njd/93fxlh/9id3n9x05zHVH9hJpRWwietkAoSAaJeB4IZBK44RHE7aMXwlT+oouATueR0KAQRApSKQiFpJYSKLR3xVliIQiQRFJQaIV0kASK7SRJJHERJBoRaIFsQrkt3okqEeKqlbUlKBmJDUlqGpFXevweGyIDeioihXhhDUrEa1KjWoUk5cFltCFJFoxE0u2swH7Y8k3Hj/M1GyFX/v4/ZhcMugMaI41+YcTT5HomHtOnmcwLAOly1vqSUyzXiGKQtegVKCbbxbwY3d/BIvZvQ6FEETSk0SSRrXCLZOTYEvWh0NsOeoCJUQm2iUfhkUj8QSNWS/t06zWEE4QqQhG27dEh/a6yC3DNLhQbqeDYF3i/EguEgpLUWYM05yyCDwn5wV+p433kqJ0dNIUrUPXs8Mv01qP4oMMWitQEq0VRiukMWitiZRGmEC2lAIKHRa9isNrlHk2PpCWlmNHbmK5l1Kt18i7W8wuzOO1J46q1NrjZP0emXXEiWRtswfVBiY2rFxbY7HTxZuYJIlpTjSo1SNOPPoFSiuYbM+xcP0041OS6/a1MInApRlal3QGPerVGq3xGlZoahXJ8rBO1pdsFJAVCU+cWkIIwcAIXOFZipo8mqUoa1FCkDpH11sK4fEu4KQOSVMbbmrU2PrHU6hBiY4dS/f/LZcf/AjV7joHDt3A4f23UAyH7J2Z4cR9n2B9K8OVfQZrm/SsZm3gWV65iogLICcddJGxITGCohwws/8wqCoH73wZg8GAertGMj6OK4foSowdGiyKy1eu8S3f+LX88R9/mN/8rd9hq9fl5MnTWFvgfdj2f9O/+DqWV5ZwvsrB2Ql+5Cd+hKWlq19S57ZzfClh7s4RgkMC3nRuZe1Zz40lDQptsYVHKUslTohNhDNxaEoKQg6zCniNURol/wnTNyEExguUUHixoxZ3aKlxwu3aYACjTsoTrFIUBknky2DyJg0WixIjb+6RBUOsFCXBJM75AKZKwr4T60YpDmH6Y71nuyxRHsajCmtpP1zkTlBaR6xjjPAkCtaHGTfNjLOvDgcO7KWfeobZkBg4NjnNU5d6dPphknW5CPo8FSmiyFDxgp4tyPIQS0QRHDFHZhHEkaQoZfj8PpzwMaHJioJmzfDi8Sn+/tryrtJeS001MvRyG/hDhcXane2hJ0pCemmr1WBtq4sUYTuYlcHHSEcGawsiZSitROMpZShYzo0KkwVtJJUkpj9IUdIjhA6AtgnF8cziNW7aM01ciXAyEB/1iKogtBoFCQRNVqBaWYwM5EgtoJSh2y28R3mPDOST5y10YSzrboBUlka9QquxL/gg6Sq2zLj+yFFEVtJJO9ihZ3xihry3xvrGFs5DLUkw9Sr1apP7P/dZrt8zx1rXMtlsoGo1NrqeRGzDWp9mvUZebDM1OUt3uU9ZTSgRVBqO9c06W2ub3HS8zdb5Pnk6pO8C3cIgSJXl0I01/uLBAV8dS64WBS2lqTgovMXLoFGLLAhb4pzntrjCyicfoHzNEb7+LW9k6aklTNTDFyXzh/bT6LXZWrvGdvdxpK1Qqx2k6K2ztbzE5aVtVi4qmgr2HtpHJbcUgy6JitF+iJ9P2Fha4+rVLxDLGdJeh6Vz99FeuJVqs8WVc4+zUIv4xjf8KyYWGvzVxz4NixFJFPFH//23+ODfvI87bnk5e/fN8If/4y/5N9/9f6Lx3P2H7+XXf/UdIOWu9OuZQPXOv1+oYAFI6fi19/4S3/kvv+9ZViiPPPow20sZhw4f4fvf/AP811//DZRURCLBGM9AWNrB2h1GNYJ/yvQtGvn8QAA4tQTvNEqOPLkFuFFEjxIjj2cRxJ1eCIyIUSIAqUqa8HNeIpXf3XKoUdbYDt9LG7ULtEoxunsjyHIHuaVfZqgIbA51bejnGVIEF4JaFHNjO+HTlza4bc8ErVqVvLfFemZpRQk961h3li888RRCSxpJRKefBsGdddSkoVGpsLq8MjrtYlQ/d0V+FEW5GworCFHj9YpC5o6IFB0VxDL4V+cOnC9wKCITxLfShu2gFAKEwZaetMixvQGVxIRJZ1niXHjNsB/aYaUURuvR1kyBA1/6sBWMFLHSDIbDEWMXKkLTcylaGoyKOH3+Cp1jRxhPNLHQiCiYznnviWWYohkZ8DprQ0GSCKSWOGdHIlIxsjoeMfNHoYTPPCq6SXfYo15t0k+HSHTQQAnF+PQe0mGfKNIUXpIIh3eWtU4XIQ1V7THVBOEsDz7wBcYbFc5euMJ0cxwTK2xuqVYSWr6GEJ6sl1NtVeiTUwhBOhigvKK7JVjrrLLYEdjC0qhkFKlkpl1h3FTZ9B7ahj17erx8cYb1jS1akaLmPXJkPawJ8KCQIS0YDY3SkWH5xh/4CT5x9+/SmB5nau8RtILVrRVAM94eZ2ryZZx7+LP0tpcxWnHkxa/iI7/0XqSEiSjh0nLBd3//fjaXBqhaxDCzYCXWSAZXlkkWFqgm02xvFXRWL7FyRTG0GYcPTpPElvHqNBKFdTnf9q2vp7N2jTuOHcPonO/6t28mywMcYpKEN3zv94eufPQd/+K738lbf+pn8Hi+8VWv5MOf+syzcLEHH+QAACAASURBVKhGo8H29rMZ3BAS/vo9/Tz7lKCBgpmp/Tx15lQwIvQlVmTkOSS6gvBiVBQDXKO+QsTSV5CZ7LTmgV2tpUQiUCPbVak8koBRKKVGie1hdCy1QI/U8FIJlNRIJRDowMORECuDF2C0xAmJUaPJk45AlEQmQSqwpWc7Lbj25AWchbqJqJiUTpajvCe3lhltmKsZjky3OHz9Ae6+92F+5GsP86KDx7nn0lUW6jH9POfM2oBcQaxiOn2LAkqvaSeGQ+NVNoaD3dO+cxKl3Ln2BNU4op9mgaUufIiu0VB3iuv3THNtc5v6ShfrPXmah05RaLSG7jDHKEXhHY1qlcLlCCdAg1YG7wzD4WB3dFqWEhVptIBqZChKF8z0RkJBP9J5UXj6riA2BluEVJOUAi0V1klwJUsbHS6vbtAeq6IRaDHSDGqJ1IHnNRQQOxncK0eRuE4JpJMjTaJEluFOZ3SwyfXPYefaLCNPt4lqY4y1xthaXcYlVZJmm7iiiWSFskyZjAwXrl5kUFhiE9GuKs5evsb4xIAyK5meGEeWwIQAaShFGET0U+j3B0zLAqkjZlrj2K0elckmg+6ALLd084z5pEr9Js3KhS3Ga23qekhzvEahBZW+5eBCnce+uEo9gvsna3z7dsa2yqiUBkvAEo2Q4b5kA5bXdxk1r7n/jT/A0nUHmGlXmZ27nqsXnkA2KmjtUdUq250VfH+NzrUVVtYbfOSzX6RSibg2dCwszPI1L7mOv37fpzl69AB7xT4mD95Cd/08WxeeIqlU6GxfQukZDt94jC98+gN0N1dZXS+J8jWiwvHW//zzI+AY3v+BD/M1r7iDsVabf/eDPxXW6egrGQ6HuwEC77v7D7h67SoPPfQEUsG//85v5cbb7uLDf/f34edHsEi//6UjtYWH73vT9z7v8UqlQivWvPZ1r6UxMUSbCmXZpSINRviRbnJEP5CEMMuv0JW9YFGqxQYjJE4KjAiFJxptHUSkR7ltYnesrFTwB5KECY6MNEoQHP6MREodEhMUREqjIxOKmQiKd6FACh0eG7HHg2hXMUxLksTwgXsf4uJGGWQq3pKnJXsmWuSZ5fhcm7k9M9jc8i+PHuTE1SEqusK5s1d51bE5Pv7oRVaynPlWg5XtPo4S5yWHZycQRZ9s0GNte4gRwaol0YrcWpwXtKoxnUGBKIrRdAGMECjrqYuYVZXT6w65sJmSaMMg66GlCr7kowXUijUoxUa/T1FYxhoN+llKVhYjb+00XNgOjDFhq+sd2kQUHnSUhMyu0qKUwERqxBcDSodTjCZZQQ5kR5woLxXCeu478SSHZ1rE42OjLZgMoLZzYbuNwAs/AqAJPlaOMIHDIR14gmjX+SAHei5wWvgu1UobOcKyxtrTTLZncIlFK1haukCRpfQGQ4QQJKZO4XOWO11iXWFQlqTrazQnphGjdaOKEitiSiSJqeDG9nDm6iPsUQ3OrKxzeL5NNnSUQrC6nBE1YlKRMdOOSFybar1g6eIQWYnp9XLG90zwsfuucKonQHRouR6PTcZ8fyopcdRG/29poSQAs75w5DJC5DnX0pRk8TRXT65Rxk1mDh4gUQrhPCotqTQWSCYm0YPTVOs9hPa846d/nN/53T/mxKVlvnhtDd/tcej2O0hqbaoqZmm7i1N9cjMBg2VKBiw/tsRErYnNtzi05zibfhrbWAg7FBu6oR//iR+mXhnnP77rFxDSIH1IXXza6D9gOYsb12g2m/z+f/8jXnLXHczNHERK+M3f/FXe+TO/zur6JeBLG7xprUMunXt+MRlmKW9+8w/ywz/0o3zyI5/h9a9/Yyg8QuGlI2omIwoCKKKgUnoB/OorFqW5sUYg1ekd0FdRMQFPUkaHKdqoKKlRsYmlDrFKUmJM6IR2ipkDIq0RKmw3lFIoE5TnKtHBhkMEuv+O0ZQXgu1en8cuPcWFi1epNupo6xlkKdVYYyJB3zv+xbE5bliYoV5rceb8Gb7hFbfyh397P396zwm20pT4nMXFAls6OqlHuhLpBVo49tQNzrU5Opvgzy6TdTJMWTIsRpG/3o/4G5aBk8GipQzhCdVYMl6PEL2SWr3C8rllpqoRq75Ct8x345I8oCKN85ZWXKUUnq1el8yV1Go1tra2g8pfBv2ZUoJIhq1t4RxRHJPnA3KbI3bidna/KY9QO1KWAq1D8IBWKvg0CY0QlguLi/zZ39/H6152J4f2zmGMCextnk6hQDhc4ZHCIUdzEOttoG2M/NjxYof0EGgYzzhK32ZivIlwOTGgGzGyKalEiixPyYoMO+jSbE8QSclTpx5janY/uQuRWZcuLnJw316s9rg0J4livDGUeUFVC7DgXYWxxjTNqiXr5QxKG9jtmWSjFyaWvY6iTLcRTqBVncaYQk9HdNcLeqfXWesOd6BLutKzvTHgnINbxieR3lG6EoUCJ5AocmXpOss6npvxbN5xPWU7w9EF6xhWHXVhWO1uURMFhYmp1ls0Fxb4saP/jFNPPsUNtx3kpS9/BY25GZJaxJVHTlFSIxeWJBpj+tZvprd1ke5GihuWrG2cw1lFbiLs+jKVdoVf/vXfeEY8luA97/lD1tY2gsDalig0BeUObMvCdJtf+5VfZm17g1q9yY2Hr+O+hx/hxKnH+Y1f+zXq421e+rIX84EPXhoVsecXni8dNjk6Rv5bkwcPMFaFwgpq9TaFFUjtaSaBp7cjyA2Wyv8ETGlhbhypTbBJ0BqkIFahKxLKkAgV7Ei0IcIFgacyGAcyfpqQpXwYDRpp0NohpB5NfHTgImmD1DtWqwq3u9hDzpxSihv27KHbtawNz7PSy6lVBMYZsrJgLjLcsjBNPD7NlTNP8nUvvQOhFF99/QEevbxCMzFUohqJK+gnBba0VKox3V7OvqkGUkJV5zTaM6TlNVLpqEjJEEczUkTSMCwympWI7SxnMolp4BkO4daxiEYiOHrkRhCOUiim6oZrvS4VKSlH3kVulN1F7vDaU1UGKWOKToetTp/xRiuAv2UoykaE/HUVCSItyNLBbnx6MUqp8D5M8oIlhNudkljnEM7iVYGUEdK7MKETmpXlLf7hwZMIU2H/whi6GlFxmmKU46a8GNndOnACgQw2NLt0jZFeD4+XGvGcRRxrQWt2ilpUJdEVxqoVetvL9F2GJaZfZszMLnDiwc8xMblAdXKKbtpjZrLF8lqHmbk5nFTYvEQJRT60NBODrlQpXYZUlqjSRlZvpiVPspqXXHliDWEStosBy8spWgqq1RraVUl9nwtXtkkqGdHpJlN1z3prjLXFwS7euhO+eTeOm4ucbSGJkVifM1QRKY5+7plEcrQa8ZG1Lb7w1w/w7153ADueUmZpoGpgqCQtfJEyvXArevo4Q5Fz5col5hcm6WzljO9ZYHx2hrf8wH8CoThybIF640ZUo4aXirSXMnvdKxlsLLJ5bpPtYpu9B76B4aCk/eQlFmo1FrsDIHQc6+udsPUqS77/B9/MmSee4BOfugfl4ef+7//EvulDnFtc5OixY3zja7+FiYkJXGkZ9B2/9Z7f43ve9G/5mw//ze56+t85vPd89O73ceOtd6CNY2tjk4mJCWq1WtgZqjAN9l4Sbmf/BJeA+dlZhFJIF+7ESjDqkORu97QTUOmF2NWrhZ8N91KpdxJg5a6lbaT1qBtQaBVkI1qacCEElRUQxHxbvR7nryzT2dpiph1zba3KjdfP8OjlRRqxZc1K/t0/fwmTM7M8/sDneMVXfxVxVaFyhdSeStVwV7uCwfDp80uU1jIsPVWCfObrjx1nvbtJrC3KaCYaMae3esFt0ShqxrCaDjFopmsNpMhoSYlyOedtyj+fmODK1oBXHNiL7Q5ocZaaMOwdn2R70GWxKLGFJUKRoFnPuvhCUIjAjC2cRUrFMEuJZQRJFNjaWlCJIgpXkBWBJCq1okifzmWD0G4rGbbGeVZi4rAd80KihMDZAm8MUiUUecm2HLLe6XDy3DkmG0cZEwpbkahCYPUIPJfB3TDMWh0RilKBESoQSpUO2014HqlkkA5xzjGzd4Kti2tsu22iqMHGeodqq4YoChYXN9h38BBFHqx/Y6VgaEmiCrXIhI65EtMrLJGGbWGpFRoXSUCR5ym1mqLIapQ2w2qJyC1NU2VYK8i2FNW6xlUEvcWM/fvmWdro0JqJWb/qOHF5KWBkXo5cLxyx9hTe8KnBNq9J2pwrC1oVSV146hYetAOeqNaY2zvHnd/w9Xzur/8aXxc4ZUB7irLP9nKHiRtvI+v1WVpb48jNt3DtyadIS8u9n/gAi70B7//IR1lNdzoFT391meGhg0yYCt1eh0qssFsrdHrnMfE4sWogGFAZb3Hq3FN87ctezJ9+/O9GuJHDmIiicLzjXT/NzJ4JXnRsP5/51D/yk297C29/x39DFAW+lNgRj3BjfX134vbwww/z0MOP4F2JEhrLC+exfbnDe8/Mvmlue9FR0IZ6PcIYQ73aGHVFCq1H1AIXMOYXOl6wKE1PTqC0hAKc9Ggp8RJibULG+Gj6Ikex3EBIelUKHSbtKAlOBh8kT/CCFtKjtA5MZKkQ0iCkA6HxpcWPpm+IkmbFMD7W4GP3P8TGZo/Dc1OcvbzIVCXmcrfLj77+6zh0aJ5Tj53ia7/ulTRqddaWV/jiicc5t13w4slxnB+y2B/SlxLtHK1KwiAdBhDdOKwvOXjdPi5dXuKW62Z4ZLHDVC1hpZuymWXMJHWW0x6rvW2KsiRHcsPeaapZznYnZW5mHpf2sEJy24ExVnoFN860uLIkyTe3WSqGtJM664MBsQAnFKktAm4kLXkexv+1SJK5IqSaANv9HnLXakTgRlsJIYK2cCcQoLQWitDd7OgAAYQL6bllmWOtRxvY6vV5asmx3s/I85LrZqeYajWYmR2nWasjdbBHwcrd/X/QQwd5jNchksh5EN6FCekzjlatyniljhkMgy1L6Th/+QLX7ZvjibMXsKllYrJCP3MUWOr1GApLL89J4ohCSIbDgoaBqqnSz0pMLEB5tNDk3hLFdYZpl66X2EjR297G9yBqNDFeEFUVLs0ZFp7xiTrnr62Tp4YTmxsMqgkrToPPkVKyd88Uly9d443f/K8Ym2qy/7o9VH71tznmFasup2IN/9/2KvrWuzj/2AOcefw09zz8BM0kIe8UFO0um6sbdDtX2HPwEBJH3GgwRp+1KyeJKgkbT1zi5EPXWIlitgdPE5DxjicvneGWF92Fr7eoF5Ktbg9httHb23T76yTVScaqbTY2hrzq9pv4979y9y6k4FyABoSCd7zj5/jZn/txbjt2M3/yl7/HD7/l/0IUlrJ0PJ1U43eqCMCIyT2SMvn/vYIEYY0cvvkw85P7kC7CVExIMpFBTO91gBrkaFBm/fAF3+8Fi9JYqwkEoab3gZfjVPDfUUrhGemm5OiDeoknyBxQEl/63SmBHOnaEGJX2xVsOgJG45zA+6AZCyZoIRI4tzki7fPaozfwhdOnuHRtiUo1Iree73r1S3jp7cd48sIlXvHVLyYXlpWVNT70yXvY6PepTu2nEJ5WIfjAUocZYyiMZmgtlXpCNky5vLjEq26/lVpFcio/y8LUfo7Or6OyjMWeJ/KSXp4yUW8wyEtumaxhnaNZb7O8sUilVWFuboIrF85y9PidNJMKf3viPD/+htt49MznuX1+kmS1x/JwwHy7jXOOy90O2oHGh0Jsgi9RpAy5y+gOMoQM3kV6hB8hBLktd0HsSEuKwgetHDKotkcGckqNwiVHQmFrPUWRUZYK8OR5jvGe5bUOV1dXuePIYaZnxncBSKnMSPf2dCAm/untG86jdAh/eO49TxjNzMwMS6vXyDpbpNkAm/Z48kKXuNJEyZxBfwupa6xeW6SyMAvU0TrD6Cr9bIuoGlEUEhXlRInFlTGFK/DCk8R1jCrZXOtQaU4i4ibtOqiGp7+Z4kVJVAuMdLft2VofYkyMaiR89mKXzZXOqMuQ3HbjAq99/Wv45V/+M/7wA+8LAJOQKKmwruCr9i3wwJWVwEh+9AthvefBouz7vvc72Tr9SWaVZ2tjGWsl0rbZuLZCfXYWkyomF25le+sy1730q3idmeDjn7+XQako8tH2i4hYT7B64RTzN9xON88QQpKl21jnabSuR6qCS2fOUR2rMMzWmJewXGgKiqdPuhPMTI9x077DNOtz/OAP/QhLG1vg7W5XJKXEu+AMsUO6hS+NIf3/PYwx6CzY7sQKlPJEsQbhkBWNK22AcLxHGkMtGn/B93thSkASoZTB+RxB4BY4FQiVJWFkuruQR+ZvYiczXkgwoUMSSo4kKU8TtoQPW0Frg+ui8CDkjoYtpH4aYxhmlkqlxoX0EkbHJHFK4RQvu/U6XnrHrfS9Y+9UQioFynk+89n7cFYy0RynMTPB+WtLdCTsr0Vc7Q05MjHOZm+bq/2MV9+wn8FgwMJUi872OomK8ZGiXa3QrEecHXqGRY9YajaHXfIMalMNiqJgKx3SMAkTY01mxieZ3jvNeKtBctMR6u1x/vvHP8Odh/fxxOVr3D7T5H8+ucZktc5qZxOXl5RKEXtPTjmy+tAMi5w0s2gd7S6WPE+DE8Oo64Fw7bh8B+gO/DAYbXx96JS0VFgccRyT5fmI6BoEm94XrAwHfMv11zHVbJF6h+3kDN0g8KCekYQiZXC53MkdU0oiR66V0kEpn12WrEu5dHWZrLPIlcUl5vbNUWnUSYeeXielVo3QJqbf7zM9PY0vHHHD4rOYghKlY5wNWJkSDhnVKCixSjEZ16hUDcNBwdzCXnJKymybamYZLhU47alUI2qRoy88SVllmKXkWcFDV1K2U7tbRYXwLMzu5d3/5feDTY0OUIK1DmGD2d7Dl9Zw3mJ34ATCy19y7Bg3HD/CicufZ23VUqtsYETBcNhnfGqGwdYG1doEly49xuVzD3H51FX+/JNnWFMS9Qw8RciSjeUOnRVNq9GkWp0kjltsDTZpjN3I6toVos1FOi1DVd9Ct2r43f/xHl77b/7Ds2AZ7wVf88pXsrKxyQ//p3exvLSCkh5r2S1Ihw8f5vu+7zvxpec///TPPS8s4J9yGGOYuv56ktigNIEaISSF8CGkFYlXHolgdnqOc09+FvhnX/b9XrAoVeIqzudIEoQKH95bRywkVgfuSrDYkKGYCImnAB+HRWxH+ERkkK4A53EShN/psJ6OcvFq9LNlIABqE+72zWaTk0+cxVnLq+68hSsbG5ioystuv5FWa4zVy5foZxkHWvCBD/8dZ66uglDsa8xS0YLFXpc9tRYbw5yXzM+TiyGnNwV7G02uW5hCesdaZ5WrG11uOHiIuFEhs0NUvc5EojmXaowTJBhQBRWjSLTk3OoGrzp8ECsK9s9MYIcdclEyNd3mviee5A2vfjEXF9f4prtu5mpq+baoykdPnMYkEe0oJvWWilKoInhiIwRlloVOSPiRTYRCoLDlzsQi4G1SyHChjDSGlHbE/LbBV4mRJ7r1QIEQCoklK/PQPltP1rd8/smzHJ3dQzuucKEbpoty5KG8I4mRyu0OH7SRxEbvsr619DxX8D1ZG2d15QKJiZgZn8U4Tbc/wDlHXUe06g2efOo0UzMz+MJTaVQpnMN5S5kXJEkNCVRU0OFpr9AVgxclcTUOXYwuyG1G3UTYZIzUCayyFAPHWKuONCXl2hAleow1KzTGIj5275WAfz0D3P6bv/uHUGVEwE3LEU5WAjhPPuLx7xyW4Jn1r7/9dfzwf/hJ3vod/4yrGx1edMM+zj/6JM10QG2YIopNxuYPkNpVfBEx7K0yXhGsDItnYXBCCE5dWeXldzQYZn1cb41umnPo+hto64its4/R6Qq2LnVZufhZTl5Ked8H/yu4UfqMUoEeUHr+7M/fz9jYGMtLK88b6zvnuPHgYeb27CXtZbsGbM9Nxn3uv5/5ewbOntl1G93tsAS885ffRUtA6TzSSbQ2IBR6FCVvRKBLlMpw+oF7kc3qC5WdrxAcoAVKJOAtUmrAIWPzrBeGO3AQ0QrhKUkC6UzuaL8CQI6PwXu8LZGxDkkmWocbl/QI70banWoALHZ4S1Jy3cJeHjn5COv9AU0Tc+et+4grCZuddartKnvnb+CP//iP0NqglCRyFl2Fuck2tbEpiqLH8YkWq90t7rjpIIfr2zy52eH81javPDpPkXvipMXC/B4ePX2SQd8j2zHfcNdR3v+5R0g3e8y2NJe2Fd1ul5m5aWa9hGyImGixsbbJTLNGpAyD/iZ7Z2e57dhx9k4sU6sb5rsD/rGzxjfcfJDPX7zGtgRTelxpacaGahKxPXT0yRFSkmY73UqxKwkYhVIhELuLCnbsXeTunc+oCOuCiZ6S4XHnwwLWXuNtEEhHSvPUlWXMUNKuVajFEeY5qLX3IhBdhcBZi5BBvKuVwOYB19rxw9o5TjzyKPuPXk82tDgsNRKc15TZkMaUodffZGF+gsxbUJp+aUmkQhiI/GhiaxQOiS0tKgrs9raJGXpPOswxHpK4FW50WjM04xiWkLGgk/Ug1awWYLdyNrXg0bPrfO2d8/zDQ6uUz9j2hItNoLTAljvx5F9+XP3e97yT7cvXMNUxMuDkZs7nP/4w2eYGhw+1KDaXWEvXaLebFMN1DFUW5qe5snSYJ4cPBlPoZ769tbia4Zqd5XClhmxHtNCIouCR+z5IY99tTBwwxCfvp3HLN9CYusxLDtzJibe+k2/6mpfzvk98Ci8D5QbreM97//DLjtu9UXS21viR//CTQcDA8zlJbuSB/1wP7WB/EmNtRrs9TWdrbbcoKQFTrTlslqKjiHotplJJQASdm0RglaBVqXP2kQfIVZeZ5oEve47hKwhylQxhfUYFQ3mtg2ePUiZYtqrA3N6J5gn4UCBOaoKJmCd0UgJAK4g0XihMFCG0QCqFFwqkQpkwlRNxjNYaKSLwmvHJNvv23QDpkKn5aY4dP0KlWcGKgmqrRZ4OqCcxTzy1Cg5Mpcra2hZ7JsY5uGeag3vmuOn6OY7vnUAWGecGKcdvuZlmrDG1CkNbsr5xDXxJo95m78IkV9c3cdJzaGqSpG6YGRvjtvkWC3OzHJibZnqswaWtLer1Ci7NWVxZRkUxUZSwZ2EvkY4Zm2jjdYW9kxPccv0N7Jmp86JDC+SdHoNhiROKSEVsZRYTPe1lwzMWjFH6WSm0Xypc1I62bEpICpuP3mOHFzKaoblAftspaP28B2VBaQvSNCfNCrYGKb1+RlEUpGlJXgwoioJhlpNbR1k6iqxkOCgoyxJbOHzxbEyiOT1ONJIOKS+wXlPaIWU+xHtLahWChFjG1OoRURQhFJSyIDYR9aSCcQGibLXrWGlZu7ZMpgykgBFYFeOswugYJ0vaU3OoegXXSLiU57ipGT76+BYfvpIzbC/QGwjufWAxrEWeJu+Fgu9o1Op85xu/eXRBPN+ATClFq1bnI+//NKfOr/FDb3sbAO/72IO84TtezPvuv8b68jJ5d4WGLpg/fIii2OTqFz/F2vIm87MCr4oRnvOM71JKbtl3lJ//rb9keu/1NJJptjprrCwusr3S49wDD3Du8x9n/tVv4LELlxhWpvj0xz/JL/6Xn+Bb//Xref/7foc/+7Pf5M/v/m0a9WSkQ/3Sl/SnPvRR2s0xfv03fwMrn/bMeubxO3/w23zT617/pcmNzvMHf/Q7/OIv/fKzHn7vH/wShU2hEhErSaPRCPbQSgUTQanR3rB19Ulko8r83tu/InnyhbMq5ahjkXq0RSuQyuNFiVIBSHWEsb9XEuUgApxmxy18JPQMzzvn0KPiHLhOTy+SUIBCBItGIJSkkGBUTG28xouPXE97coHr9syxPezjixKR52xcvEax0eXMhTUQJSvdkqsdiyprZN2M+VYd5zO27RAhY5LIk7qSoS2oRgrvcryWZKNY5MXlFTI7pCgtZ86c5eDeOkUpMNoRe8iFY1gU6IpibZATRxKjBFevLbO8ukhWFhQ+Zf3aCtc2N1ntbCISw/y+OcZMBe/SEVisUIWl8ILusEBVYoQKWEoc6cA/Eh6Je9Yd7UsBkztfclEGc38/YruHJ5/2AvejilaWJZSerTSlMwyFJ8syQuRxeL60NkSq54S5qbPYMqd0BYUtKVxKUfYp3OBZv0tdadI0xXuHMiGmtBon1FpNet0UaUP0tlAG6cPWIxvmJC7CekdpUwoJMtYIJwLfpVkhy1JMFDawsiyxWDr5EOk0okzIbEmKBD3GY6e32TOzwPHjN/HIiZMIWWKlwboCCH5QcRS6dO8lv/ruH+NP7v4gBs8ouOpZF461lv4w44Of+Hs+9LGPMvIgRCrHhz71BN9+Y4zOC1q1Kl4JYu/RlQbDIoety5w/eRUB6JGGcue9Iyf5q0/dy1d/zR385e9+kIENF3Ln0mcoekP8dkZzdo7HHrqfV7z8NfR7kq1huOGYxFAhpqnrVCox/8d3fPvofd2XDA4Y+BKjBL/w7p9FSYPXozBToxFopmYmSUzCqdOPPH+NCbC2IM9Lxtst3EgR++53vo1StFBxUHnEcbwr4EYFlwVpS9pxQpb2qVbqOGF21+GXO75C7psO1q2iJBICIQzCS5wM3IOdGCUhQqqtUyIg/j4ByiCYYfSYU2ERBvux0DkVO97VGghm57YMAHrhLFpI+r6HdyXtdpuX3XU77aokVo4yz8gHOZVWCxs5zi1uIyJJv8y4fWGeqfEave0uLk/xJbSqbYxM2dhYY3p8HOE8C+MNxqoT1IyjU+0SRRFLy4u86JbjPK6usLKxwitm53HucXwO03NTTE+Nc/bCWW49cpSLpy+AKzm/eIHt4ZDe9pCoLbFZTk96Hn3yNLccP0pWeJrNKo3JOuO9OpHWpNmA1FSIGFKvafSgx1i1Rqc/RJoodDHOkVs36na+/JTE+yBwRuwUKIG1JUZrlDSjoiaR2mNHu5fMlvjcstRZpyYDs7sdV9FGQmqFOgAAIABJREFUYG3okgubERtJ6Sx+JLy2ZbiostIihUE85/dKo5ipVpUiDYMKlw2xSR20xBceWZE4LfC+wKKDpa+KUEiEiSiKgopOsA766SZWj1FtTNKoVVHekZcOWTGBjGfCOqvVxxjuvYuW7SEnLH/355/GxIr02tKIgQ7f9bq7+JOPfpa3/9iP48czfv6nfxuE4Pbbj/J7v/9X/NRPfi/tyUmyMuWn3/Yb7CQ9j64EShdO3NpWd/eitdYyX4fmfs0bfvLtsNrl6lOPsHFtkV63YGp6kkcfP8Mf3HsJJWLuesmtKASfe/BBbFFSUCJtn5fUNnjxLXdy393/L3e+6naim+/k2pmHqbQ0gogp1eSV3/YDCKUpbMlnPv1p/vju97Jth8xN7+etb3snn/3cfS88UZMCRcQv/uIv0JiYYH1rCN7SXetw4tTDvOSO21DSc/apC897qZKKWqypqZjVi+f4ttd+Mx/924+w78hR8txRETGWglq9glca6cD2SzA5zZm9XDz9OapTBwP44L4ywP7C1iWA0Arlg/2s8zuhkaO4FOWQXoBVuwZmQghc6XBliA3KfGj7RelxFgpbgg93qbywgBttW0a2ooXD+ZLC7qR3ho7LuZJY9BF1T9XM0xukkHXZXi5IxuocuXmBf3j4EkY6ZufGOTw7x6W1a8zOTBF5y/Ywpyhymq0xShuxZ3qaqxdPct3eBZJY06wmdDa32L9/P0ZXObp3httvWOCBxx+jjyF3nmPHj7N98QRb3ZKKzDmwMMXemVkeXVxkOMjo9/vs2zePyVNWVzuMjdXwZcrZK4scObiXY7ce5cLlS4xXNOPVCYwpWNoeMFapcsPsDP1LV9gygqw/DO6OMiwIpHhBqn9Q8wuKvAQng6WJD92RVGa3ayrLEV2DkVeW9awPemi1SiupUjWSyNdGW3OBGOXKuVLsuhOW1oJwGGFAWpx7zhJKFIPCE1US1ldW2buwQG/YJ6kaqjom8yn4KESNC4HzOaVMqKDJXXDoNN5z4fRJDh0/RsVEIB3elQxdcLtUSuCThDIvkcR4BPV6lWZ1Cr8+xAI2t6NOCN72H7+XwUChxP0YY/mZt/02nhKlBFtLK/zsj76c7uA8509/kXf93sOAfM50KhT1N33Xt/B1r30N3/kdP4gYTSjf9F3fju5vcOIv/pQrpx7hm777LZx4/B7m524gq7T4xIkBpZdoCt78xtdx6tRjvPa1t/FTP/PbeGUoXMnemeu47uV3cu70hzBWs/3IaVqNJlvDLifueYq7T5/AQvDIEuFa+zdvfAtv/cHv4fEz/5N//Oznv+KF/pv/z39j4ApqE9N84b5H+Pl3v5sfeusPcduNx3nNq16Dt44o0mEinj97rVlrecsPv4W4bqibNq953dcyWL1C6SWRibC2pNWsI6UInqfaILRltrWHi+ceJKnO4JVBCYcrwP9TyJM4j7UCihK8I7MWIzye0Z1qROAKkS5gnSAvS9I0D9E1RUaZ+5BuUtpwYXmNpwhbA+twZbF7keyMocEFB0gLQhjKMidzKdPxgMZ8TM/A+dVNEicYyiEV7blldp57Oc/X33GMPRMTnL50nqpU1LxlJR9yYHKKTSUolObKxUvkxRTt8TZb/Q6GCBMpHrt4mrjS5NV3vYiPf+4eLi6f594nVjFCc8PB63j44UdYmB7n5lkYbm0htEKUQ4Z5xtzcHI1Gg0qtwmBrG601BxZmcFLS2+4jdIIQglpUMCmHJBXNseNH+Yt7v0g7qlCNHV91wwFuWJjiVz54T/BAdxKvLfZL1qMAygazttE2WAbukHOBvVuWJXrku7RT1Ha8cIINcaBxrKX9QL+wFlPkAQ8UwWGgLILSHKFBhC2LKwUljkgrUOmzfqsoj4g1+M6AVqPKoCiJTBx+H2WpugSvTRC7+hJjErRQDHGMETGoSRYfO8OhG49RMZosz4mkQuuI/0Xae4dZWpR5/5+qetLJp3PP9OTABGAkKRJVBAUzoriG1TVgWBfX3UXddf29rmtYxbCKEdMqa15AjJgQlSRBMsPA5NDTuft090lPqKr3jzrdM4Mw+Hu3rotruGae6e55TtVdd/iGJE6wVpNqDyE10iYEHRhH5EUk0uPan/16URcKZTlhy2Z+9ou7eHDrQ6A1f7jtbqzMwMJ5Z5zMq87voWvdMsrt5XSvmObEn27lTxOaBVNGicUYiYfhrJNP4tvf+I5zhTaGCorvf+prnH/RU8mlU5x4wnk0dEh3pUrYu56x++4mWjmE2DXMueedRVTpoX/ZMm656RGEpzDa8Poznkpff8T05Hb6i3mmdjzKXFvxwI5h+tdW6Tn7ZbQe+MYi/GMhMT3jrNP5+jevY6o562ayHYqWtfpxM6VHH9nDqU8/gYmD43z4Q/+OEILPfuwznHbaaZx22qk845lnYWLNMZs38dB99x7aZVIitGH5mg0oGZKLIvbuGuGY007BzzQy8ikp31FKrCE1ipAmYdjHPbf/Gq9SoFqpEujEueFIiTXJ/3tQOrCrRpqm6NSQ6ozEuEBlDK6hqnHKhjpz4EhrnfKhoQPac7rTmdEdjIyr6ZXgUPDBjRKFMmBsh4QrCVRIFidkJiaMIB8FDE/O0DObMTz1CLVGi2KpizS1xM0ZJqaaHL+yFy/vM5fGBFJTrlaZn2tQyEfkSj6790/TWygTaxgc6GV6XCMbMdNezFBQgN5BHhkZ5yd/uIGSL/jD/eMExSJifpZf3H4nJ65ehtaa8TjhvkfG2bJ+FWkaUwjLDC7pY77eRHlOlzgqlvBDENbDY54on6PVmmL0wAGqlSLbx1IuWrWMd/QVueZXD/P73WOcumE19Szl6QMVdjZaTDRSYi3wPNFB5h5abizLotpgmugOYOBQCm+sc8/NHgeTIlAIX5ALcvSU8oRRyFTcIhCKnB9gMs0C+klri/LTjgd8gBUZxqSkiVjsHS4s1/ex2IJPzg+R0pIkGuEp8n5IpiQm0wRBgDHOXdn3HHp8enqWUqGbnpWrAYs1nQFIJMkyTVAQiCzA6UFafD8gUDkyLEIJNDA+McOCKcK7L3snl3/sU533ofjSZz/Jpf/4zwgrUFZwyStPYdWSKlGUsH/yLobvneX/fPiNXHXl9Zz9mtdSKXfxi1/8mn17xlixYgU67OJnv7oFJR2+PVaak47pZ8eN97H2KQPkBidZsaKfWD2dn119PZ/85T14QY53vPlv6O4Z4JWv+3tcz6dz2JEMLZ9gugYHv/9dlLZM7I0pDlVQnma86zg+/9mvI8Uh8rXqIPxvvelWPv6xD7F15362HL+eB265lf++5kdk+vHH+ldccQVXrPs0//iPl+H7PmnqkoHbb7+dc885j8ZcwtjYGO94+9/zd2+7hMzoRXbA0LIl+Fawf98kWx+5i66cZdWSJfR2DzBXn6La399RtlAok5LZHPN7boWCz8DAemKbkqkU1dk70h7dzUQcDdH53gtfYa21DsErnLWStXoxSAkL2jrgpNau3DDZAifKibS5DSQWfcm1sYs3TRA4E8Z85INNybQl1q4ETBP3UuJYI2TKxmVlmrLJweFJRubnibyQLQMF/udP23n62uVsHZliy9rlFPNlDhzcz8blqxkaqDgJ0kRTCAMm5muE+QLb9xxgy6ZjUbkCUjd4YNtWuvuWkM9ViGRAK53gulsfYqYOxg959QWncdMtd1HNe/hC8uDwJIG1rOov8axNK3hw7yhbNm8myWLOOm0LD2/dwer1G0nNPLWJGW67fzsXvuh5JEZzw09+TL7cw92PjLBjbIZ/ef1FSJ3yni9/h+lmShAUaWpLnDScwoJZcI55bFBxl2bOl2gESaoXWe9HPLfIKD9y+SogjNwkdcElV0jJukofg6UynnCUIGeomREFOZCuB6hTs1jOSQTff/DOxa973nNPIxA4wFxgXWtRKHL5AlnaRMk8QlmstvhhQOR5pGnGru0PcvxTTsT4EcIYlPRQvsKarKMZ7uEBVlu8wENKSSY0AhdEU5OSZpbPfPq/sCbj3POewY2/vZk0dfCKjRvWEHqGex7YRRQW+elnX0wgcng5QZQvM91u0U4Et//4N/iDPWwfH+K/r716Ua5jARy8sKSnsEbwfOlx8uaIzS89kyXLT+HB++7gbz97A8LG+FLx9a9+kNqc4J3/+L7OqN1bzGSxlh9f/hp+9ZVfU7M1utcNsvePwzztdW/kXz9zJcqTWH2IUnT4Z//v73s3a9avZP+BEY7fcizKSLbv3sM/XPavT1jqLzTADw9aCw4mCxi40898FvfddzfPec5zuO6H12Ct5YzTTmd09wE2HLuSi974ZkKVpzkxQqbH8SU85bTnE7ebZCajr9jDPXf8nLA8QO/y1QQqxy3X/4CnnfNShEycHpiUnH3WOU9Ywx01U2o2m3jSiYYr39XQWZa5HpFwFtVCuFtsIehIJJnJEEa4CZ0VpKSumS0Eni8QWmB9qBRyLOnJ4UWSoYESMkmZnpuj1oR6BlNTbSpVSW2mwe7xBolXZ3imwRmnnsDOex5idGqefdMxflhjWW+ViekGD+zYz7knbSEMXCAsFsqUCpK51jy+McT1OptXDpEmLfy8T6vVYqqeUSq3GJt34vy7RseZaWtWDAwwMjnH2NZH6S8UKFfyNOdbzCcJz920Bs/XTEzPs3SwDz8IKXflaMcpd27fwcCSAZKkhtUeP79rBy84v0FmoFws0lsu4Zu9FIIcn7j6lxwzWOJjb3oZjTjh/d/9Kem8hDAkMylZ7G79xy7hmDzE2iyScx8bkOBQ03ORboBAKjA2IU58PE+T72hdpVnC3sYMic7oi/LkgxDfC/GFB77jnhndxqoFUrDrOx2+jIjRvo9INV5WIrYNCn6OVtzGJ0VFliAIiNspQmYk1kK9xvEnP43Qi2ilMVIpkjih4ju9bU917N+Fj/IzlNZYCVIL8gUPG1tKUZ62n2JsxsUXns/vb/4jOnOZuTCGV1x0DlPTbe59cBeZqbNvZJJjjl1JpauLRsOiVQEpE57+4udiUskW3eDb13UUNhFY44FncE71rmcKMLd+iJadpmks+w+McNlnf+6ApXhc952PsXVPm8v++b2HvaFD9mFCenzwyzdz9hlP5U2v+Cuuv/5/+OUNI1z3mSvdk9mff6C+H/KJT32cnmqJ7u48QwODJFmLhk259Q83HrX3+HgZ1KHn3UDlzjtu4fSnncqxTzmBa6/5IWC4+dZb+M9PfJiobzkhEmUyit1VjChSoM7M/juJ6SbsH2Lv9jvJd4f0DB2D1JZ7f3c3whN4oo3FQ0pnx3a09SQa3YpUZx3in2uEeVIhA7lYrkkpyZQiy5JF+ohHSJwm7iUYixf4nd9XGGMpVZzcx1M3dBGblvuw7RwikvhZwvol3ZQqZSZmEsZH5hiNAnbsHaGRZQz2FPn9zXcy2YqpqJAV/b2cvnEZN9z1CG2jufCME2nr1PmId1XIRwF+ltFdLkGWUpurky8VQRhWdZe4aXScc888nat+/jtO3bKe39/2EFHoUylWSLMY40l+t3uYVaUchahFdznHCzYdQ19vhdrcDJPtFgVrKOYkXQO9jI1NMjC4iqmpKVq1CUYbGSUZMLJjL6vXrKC3ZynLh5YycssDnHzsKg6OT7Brf4PPTf6GtX3dnH/8SnbsnuKRWpuJRowV4gkHb5k+XDCrE3z488cXApLvO30gKwCdYYTBU26AkSYtVzobwUTcQCjJUBAgyAiFRxZrtEjdIRUhQhiM6ehNHba0tqAhMAIZZVSiLhLaRMpDGoHOJGmWIn3IqRI7H/wTa08+BZ2BtTERBj/IkwUBxqYoGdIympwfIW0GQYhnPdrKEgpBlmgCL3CGEsYitGDjsf18/5rG4oj8B9//Bld+7TvccMONWCBLYemqAaRXBRMz225g4yKVUoXMZHh2Dul3c/t/vZo3vO+XbB2eQ2QZ373qSl79qkswHQ0prTW3PLKf/ZFl7JN/oJovct33v8L0dA3ymp9f/wc+f9WPn/h8Gc0dO/ewv93gac84l+9d9zCt9PGDysJnGIY+H/3If/D2v30zK5eeBEYTiQDPkzS0fMLM+C9ZnueRJAmN9hy9pT4g64CfA6KuXiqhwgpn4OV5IV29VaRYTmN+mmRuhPajO4l1wIbTn0FjfB6rBdUVISeueokzs8BBVeyTTOCOilMS1pCPcpSLJfLFHGEuv0gtkR20tfQUvq8IvBApnYZvqjPXP7KCSjVHd18R4VtskBFWJOuGfE5/2mrqUYCVAflcF939Q4SETDUT9g1PUpupExZh7eYBTtpc4tjN/UiVMjoyDULRaiccaNQ5YajKT+99hDSX5yWnn8RsKyaOY9KsTatRx2Qp+UKOYiFPqatKqa+X4bFpshbcdv+9nLTueK67/gaWL1lGsVJkTguW95ZY353HN4qoXWNvLaUUSJqJYvveeawwFMslpmcmyGYbID1mJqcY2z3CPdt2MDu8l7GRMSZmM5JUEOULDHQH3HD7TRy7biVJkPGCk7fwo3u388DO3awf9Al0xH2PHOAXD+xnqmWp+B6e8B4XLOkArIe85Y4Qgv8zimwHMuA5EKYfLJCgXeYbJ51LR2ekxrHKe3MllhaL5LwAss5tusAn0Y6niLQEXvBnAGiTCqRUKD8giELa2Tz5sEjatggV4gUOs9Zb6UGElnWbj6OkAoqBRMkA7XmL5aQiQAUSZSXCWsJQoTOLNJZACpRxNtRGGASGQhhx6Vsu5KH7p5AyXjycF73y9fz6V79B6JRvX/UFpII00dRrM8RNn7gZLeK4KuUinp+jEGgSlefyfzqda7/4Gv7r8vcRt2f4xMffv6hbJaWj++xte9hGnYOTI7z7I59F5HIUK0v53Dd/ckSm+thlpEUKydSBCZpZwr7hHTz2hT7WibbRaDA2NkZ3bw/1VGI7nmrNJCEQ6f+KYJumKZe981Le8sY3sGvbnUSRey+XvOk1VIslREciWPlQKkd4Io/yYP2y9eR9g8p1Uy1Xmd75MLvv+Dl9/WXWrDq+I4PTacAb8bg4qsPXUTMlbd2GDEKXwuo0QVin35xo7bzrY4PtsJEXpnDuRTpuXD1ps3ldP90bqixbtwQbBthWm9pMgyDzGW1rZg7O0pzfCSplVU8R61sOjI7T21PFFAxxltJbauPLjHpqmGg0aDTh1PVL+e32UfoKFY5fu5T79u5jXV+/y+iUh/YiMl2nt6+P5myNndPTLO1fQjHKc+0tN3LxM5/NVdd8n/GW5ZUnreH3DzzMaeuWkJMJ9+1v0koSVi3ppruRMlKPsU3L5qVVxibH6RvqYu9Ei2Ulj94wILaWEEE7lUy2NAf2znHyxvWM7NnKU9eWeOChffzk9u28+DkvRM5I0g0rOOa+nfxuxwxzDw+zKp+np1jCzs7T0k2mGp1g8Difn7MIP3LzSfexY7BH3JYLcsVKCZRyet9gwAvwrMUaQ2pSRxdJIa+cm+pMvUU7tESejxUCawwiTsj0ocwt5/05KtjrIP2taJKmEj9wAvdhXhH5FTLRplLtYnpmmjDnoXISG7doCSjmcyjl0UzmSZsJ1a5+TEfDywsCjNV4nkBoCVisUlirUNJQCAuUllRIRcqjI48gzaGmP8Yilcf3v3slU5M1jPZIhSWdS8mHbVqtFtV8nlKQAxLCXII1Ibm+ZUSDqwi7erjhmtvp7jmB73zvO+5LHlYKGVJaANZlGw/uGOGDH/w7Fj48KT3yRZ9mPX5MCSX4+AfeSq5UZW52hHJomUuddLGx7qe3oqODL7JFU0ilFFd/53uceOIWzrngHLKWptFusmLtRgQ3dOwsjr4W4TtH/DySUqFMuW8px5+cccHw83nd37yQ+bbr2YXSWYWFgSJX7MEzIKMiw9tvJ5GC6pLNeChqU2MsW72WRx++g94lm1E6QKvEUZzCx2/EH7mXj7IW+kfNVkw7iRelbaXnd+gkXkfvRzmVxE5/wZkzOqH3YrnEHBIThcxPTdA4sIu777mXmelx9u/bDbpJPoRisYhJPe7aMc70fItuPyMgJWnFICRC5piqtdk+M8d009BTCLlt7x48Zdk0VGV4apxyqUJvfx+5KADhoywUfR8/iphPM+o6Y//4KCOTB1i3ZDk33n4HKlciUj41Y7jzwd3s3D/FgyNTHJydYKzVYHyuycqBAcpFOHF5lfpsgxY+t/7pAboqZVYvX8GK3j7yhQo79o/SWyqwZvkq5mspW1b1cNejk/QUi3z7lp2cddxmGnOzjB8cZs/uneQ8w6lLlzEbJ9w7Os1vd49SS2OeurSP0/rLjl6ij7w3Fgw/F2yaFtbh3vHCHvn8AkrcV+42lNbg4TS2pXLkSWwHToBkLm7RzjJ8gUOVm4Q0a9FyDpidFFwSJwnt+EjSqlUO0+OJKigPKSJspomkhyTDthukcUY+jMhiSUBA6gm8XEgzywiQRH5Evlp1OKY0I1QeVmdoBMqz6ECRs86wws8HJFgefegeJmZqyNRn09BStK86igBuDH3llZ/n0V2j/NO7PojyJF5hJdbLMz43wfzsKKnxqes6aTtGz2a0kjxZYlHGY2bfCOtWWl735su4/U/3H/VA3X33vXzwgx/ufG+DUK7iaNRbf3YYhRHkin3cfNN9zM5lvPGStyF0h4wtXTP/ZedfwJeu+I9FAOwC1OPGm2/jW9+9lle8/A28+KLXkFifs08/jfDoScgR++WxWZUSIHOCmcYYe3ZMsen4ddQTHyUlgQpQfoDyJV1dvQ5V78PcgXuYi9tU+44lVBJsSndvD/7gFsLKKsaGH2Z89H7aSZ1iuYJNPaQ5+vTtqJmStZY4bSM7vvTGZqRpRtbBFikJxjrEtsMgKZIkwQsd+7+rWmHzhiGUnsImGb/btoeBYhdFVWBudJrfPfQwq9cuZWnUT5bEeCKhlAsZmW4y11Qc6xWo9Ai0lfgtj6GeHHumfKalYMmSLqaHLesGe9hRm2XjUB9LB1aQxfPU5lqsGerBoNEGDu7fT9KOaRlnye0bjzyKMRXSSmIST/OjX9xOw/jsrc2QU4oTB3u5f7LGg6MtlhRroMtc+9AIm6sRfYFk7aaNlMsF5lsNLJJWvUnm+eSDgJ37hin0an539zaOWTZE0wbESnHssiF0vcVv73+EXK7Axv6IGyYnKBYLxKKJzgyjKfxw5xhpZrDCw7H8D+sTWEfKdfp6HUMt4co2YQ1CCTzfJ021y6iwnUsjQ0uPXJinkbTxrcMJGdFRbTAWlF28fEppTJblEWRkQhD5nRLHCHSHhI0nFkXCFje26gBpVYKSZRAQBYHrV9GiUO7B6jYGRS70kBY8X5BaN7HL2m0C36IUxCYj9AK0ddbstqNZbo1AeCFKZWTNFscs76aregqNRosgF7Bq/Vps6sSeJJbLP/YR3vSmt3ZgFAIpPF73lk/w9U+/g5lxi9fbz0y9Rm9PBSlnMSokCn2EMsRxg/rcON+6bhemA4fvoJce98wsTCUXMhq05sUvehZ33buT/fv3HhEILIbPf+U7bHtkB/Ya6aZznUCKzbj4ogt5+1vfyN7hXURR5KhAHOovjU9OLA4vvvmVr/Hmt72ZL175Bd7w5rf9/y7jhBBsOnYja1dvQYkW+4Xg2ONP7HBQrZsYWkNXtQuTaUTk8+gdN5EvJSw95kyEzZzwHAaJh5Jtirk8+dxGDhx4mHJrlq07t7Ll9POYnz76z/akmVKaWXSSoLOMdquFJwS+VATKQ2uLyRzq2vMCpBKEkUcgPQLPpzunqHZXWHfiaeycnCcQih3De7n7wEEONOaJkzpjB2rsObCdVmMS5SWs6imxtLebQObYfWCcrQ/tYGp4mHt37+PhkTlm2xkbiorfb9vDYOjTaLToinxyQYl6Y4pd+4aplisUCgXwBXPtJkHokc/nWD20HJFlrBjqZ8vaVWwcHGR/rc6O0Sbjc02acZssM5SFotZMSFuGrqIklytw2/59HFOK2DTQz23jU9y1bQ/zMzWW9Q665n8uxA+kE8TzJBedfjY3b9uPtYIdo3PMzM1SySVMTY/xjdt388iuEaamZhhuZnQpn9QaQuUEsWzm0Ow6zfBVcMQGE3RcXlB40sEAlBREvsDzAxDKEah9OuJ5ZnEIkemEetzACkNDW2fvZMRihmSMc0TWaUZLdLIi3DlJ05jMGgdaNM71WGoB2ZFbqJUKkrSF8cBkDQQpkoyZ2hSh72OSlBSDF2gi39K2PrEuYrBUvQwv9DBRDqVCCl6ACnw8adEdYUArfQLPyTM3sia1gyPsH5knbTWJPA+bpcRpi9e+9mUA/O2lr+KjH/0oKMNH3n8pUhoQCbX5lJdd8mne/v4f0dN7Pq95x9fZfXAXE48+iFfuww8iDJaJ2gTTw6N89/rbFv+NhwckJZxyQug7qoxcENgDvvflT3LVlR/g7970ekb27zvyc+yUvQ9v24nWAoN2KqwWwPC1r32Cd/7tGzG6za5tu0iSbDG7eSydRCjJ735/E1EYQqhQTxKQFtyRPenI8wgnyfJP77qMV7/6Ym76w61sOXELfqBc4uFJvCCkWiwQCI0hY+sNNzG4cgkrjzkdpSOE8bHGGddiJcKEjowbSFasOBavvJRy11JGt93JvkfuOOrP96TJnsCB8BZTT+mmN6ZD0rTCddQXmn/WCho6IRdGTDRaTAyPcHDHdk444QROP+tcmhgi2WZiaoYVpT5spgl9QStJqTdido+NEnqW5YPdiCDHTDPjwFSd+3ZOMDLXpj8X0lQhq5f0I6OA3p4SBS+ilbYZHZkmXyxTKhewJiONE0qFItqTNOpzFAs5EmEYHx9neGYSieH4oRJrqkV2NmfJRwGBtGT47JhpYVCsqnYxncaITNGWLR6dm6GVWE5aN0B3uYfYZtSSOiLLSIxlqpnQU+7iJ7ffzdqBJbTSjLm5OU5dXqYYBVx92zYsGd0DVU467mlUSJlrNlhS6ZRrQpHl2f4PAAAgAElEQVQY56Lr0Nd/3vjURmOtRilJyfPIeZJNPRWWFhR5X7jsFkGaaqdxpd1UzGiX2apMYIwjtRqbOcildR5dkfLpCiNWhWVy0tFVcl6E74d4eGA9PN95wSnP+zM9pSh0zWdlimQWAqmYrc8TFktkVpEJgxQ+UkQkNkAFGhUZAiD1A7R0pp0Zglhq4iRFoshLgZKWvOo07UXC2IGDVFeuwfMUwg/A8xB+Di1g07HHUEFQKOWZrbV48fMv4N/+/YoO4t3tbCEE3/jO53jBha/E8wLWFLrZ+cAYUVCEqETWbDE/1+S1770e+Thi90IIrvvhd/nZj77NZy//MAqPFzz/ufzmN9dx1VevILWSBMlvfv070iOgE/IINQgpOxQeo1FSceXnP8HQ4EoHw0GRKEkYiSc8rgu9JiElawYH+P4Pv0UujP7MaWZhWWvJ+5KvfvurbDnheC5+3ot5z/vey+tf/0bOf8n5KKVcqdzxbAusJRd55Mo9NFLLA9d/i5UbcnT1D6KthzatI4YtC99DSAumQ272FJWBlRT7N+Llq08ccJ7wX7nwhbVzyMh0uojubLUdrSBJEidlkSSd/3cTt1QnKC2Yrk0xPT7D+EyDkbFppvbs46G7buHZx22kp6eHnqjIZLPJowcOcOe2g4zPzpNZ6Omt0Gy3mKlN4euYWr3JIyNz7BmfJk40Q90livmQNeUSu8cPsndqivp8m/sf3UmSGgrFkFBJquUKuhXjS0uaOAExpTO8sExqUjwhmWm0GJ6q05ULOLW7hwyLFj4NkzowHZr7JxtE1mNDXw8j9QzdinnruU9n7eAy8pUCg7kyfsf9NzSC6fo80zOzTM62GKtNMN+uU9OankKZL/74Fn78wD58DTkZEps2fi5C+gEryjmstUSewmpXGkshF+WEEa5hqoVBeIIw8OgNI565sYvnrhlkaVfE2au72NBbJvKccaXv+yjP3YpSSvKBT94LaJsMYT3SxAEhsxSENGTWEApB2Q/R0iGPC2GAH3qONNvR7Fb4BL5PGATkg/CIPaNESj6M0EmKMJY9e7cTVHqJwpDESMIoRyAlvnIlWd73EBj8IEIIS6gknoFc4Gg5uSjEoDGeBCSJVbTThLtuu4mVK1YQeZoE66SAre7c/AYlAl7w8pcyMdbEoHnlK15IYlWH/C075OKMrOn2c2oy9scZyp+mPt8kiTX1mTqmXcb3wHiP3+nYtX0fjfkG/UsL/OwX3+eWm2/mOedeyDXX/wKRM3ikVAeHCDrUigWYwuHrWc96tlNiVYK/e8vfMDlTZ3xmEj+Xx+iEc84+C79jSfa457RTKu7bd5CWMeQKEa/8q5dijF60OltYQgg8qfi3D3yAUpjjn99zGc94/vP53reuRvk5Xvuyi3jWuc/CC92ecbbugny5iIqnEVNzLD/1FDJZwGQhCoP0zSLSfOE/R0FznolCelgryHkCbQwDy9YcLew8CfdNCtI46VACMoRw1tEuyhun3WxU59Z2Al2+ctbSzpI6Zv/BKRplj3pjnqw+Q5pqvEwzMz9DpSvigsF1jE3N0M4M0hr6eoqkLciMpEWb3qWCmR0HGZmeY6BcQocB06NjjOmQhvEoBwUeHpthdX+Van+ZrlxIpZRnujZDV3eZSrXE+PgYgdLYuE2f77N7rMnaoSIBGRv7yqSpYuvYNCGCgjLEaUoYRug0Yd4m7Jnz2V2vszLfxalbNlCpRvj5MjqZR/kVckoxbyDL2jRTxUQ9ZUmlyu7xKSqVEjsOzvDLkQOoYhelXI5ASe7atosdI3swSRsjYLC7n0qtyWwzQSqnpRyFgmY7W9TFLoQQZz5CapZVc7zizONIW/NUKhXGpyYp2hb53j6CPRPsm27RSBOCoOSsw7WTI262nGGCyFInUYwE6RxFBvIllpa66clFBGEB2ZncmSRDeT65YrGzaSypsAgrSdMjG92+CDHWsnJlP3tG97N8wwaENniBj7GCnDDEyo39dYdcm1hBZhTSGGTeiQka4Q5UmmQI3+9olaesW7KCH/zwfzj1jNNJrSQTPp6xOAPUjtW4jdDCcsLJG/jtT37Jyq4uRsYO8qlPf5BMJIzuneAzn/kK//Qvb+Fb37zGUZ5sxh9vfpQXPOcCZDrLxPQEpVwXl/zDv9OGwxQYDk2XPZPRv6qbrN3iox+9kvse2tahUsF11/yc6396w2IfyP09hRCar3/1o3ztc9fwx/vvZMXy1Vx66ev5q1deCEnG9777Ix64+jqWVvv5+3/5B5K0Rc6XfPMbX+LCi173hEdVa807/u5Srv3B/1CqFnjtX1/MBc9/EXt37eay9/7LEc9mRrNy7ToEHllW5/+8513MNVv4vocMusiswKBIPMij6e4p0zYxftMyaw/S030sUnkIBUZLZ8XVIdm6cb/Flz6ZcC4+2hik0egFvbXHga38xUFpQbgNWIzSSdLuREXlXFKVxmjfkfGyjMBzut5SaOJMMzs1QRaHPLBrlMh6dJfHWTY0SKm3m0cf3cnuusUqy/KBftppm3u27URqSylXZMXgIJWwQPEpZWwY8dv7d9Mfaw7Ox0Shx6nLV7BzapJq2acrlyfAMD87x3TOo7vag9IzSOXjBQG62SIXlOktzNBetpK55jirlw0yOVEjw3GxjokUN45qBnMeexp1QiEoCMWafJ6S8jh19XKq+YzZhqaaM7TbdbqXr2DPtKTRihEqT31+FCl9JudnmU1TkpE2k7VZclGITZqEYQ6RJeyra1YN9TKQGKYmMx4YOchYvYlOUjw/JIljUgODxYCqpyjlA+om5cQVSzj5mBWUKgH7hicJohwKRW9XEWEqqFRywlAPB2oH8aOQgh8w19TEWZskca4mmQWMS7eVJyj5BQYKOcpenmIUosK8U4gQAikhs5I0jrE2RciAGO0uKy9EiiMR3VE+hzSaqYNTVP0yfiJJfEO7kVAohzRTix9ImkmTUimi2WqTzznvPY0hzSy+sCRJRikqQOQY+6mUrF+1irGZOqec+UyE55H3A3fJ5QKU1R0RN0smJQUEadDFs19yITde9j4+/NEvEuXLvP1tr+Y/P/kFvv71zxD4kis/exVCOOufj3/zl7zgnBch+p/G7F0/plZYw39f8yXa7ZRXvebSwwKS4x6+9dK3cuChvbz7Ax9GKeHApIetND1ySOHIspJI5vnbt72cfyq9jh17Rvjof3yG++5/kDRNCYKIZrPJ+MQsl7zhrXzpS58nV65y+x13H/UgA4RhyJ/+9CdOPfOptDLN3ffdT5DPIeyCcumhJvmrXv5aXvXq5/O8F1/EzPwcK1ev4orP/SdJK0EKn0AJkJru7m6s1fzh6u/z1HNPpXvpOgIvwBiL0RpPBYvihFLKReCuwTlbH5LM9nCCtI9VYHicuHO0P0zTlDAMFx91qa+L+FLKjtSTREhnOikAqRw/ziIxHV0kg6S72M/6FUs4ONVg2+59rMxXOGnLZtavWUIxr4jbTebnW0xP1JibmncIbF/QqE2TJW1OP24tXWGIFJrBfJ5QCXZNTzFYLpHH0lXOofyAzRs2YoSkWMgR5Mv45RJRFHXwVXVaNiOfkzy8b5RqoUz30j7GGjGrB6qESpK2W8wlCQpFbA3aQCpT9k1O0dWd5+b79rJp6QDatMlHBWrNJjZpE1tDPWlTLHZjraCdCabn5pFKk8vlaccpYZQnazcRQUil6JM1GxyYdPIto7NNd4OIzgTTk1jpDAUKIfSG8JJNyzh5dR/GNJk7OEoziRlcMkS1p5fdYzXiTDOftfFsRl/kFAIa83XiuAUd8LWxwgUkwPckVT+kP5enpHJEoY8UFkyGlC4TjuMUiybTmnaSOh2oZsvBEqxBmyMRyElznr179gPGicdp12csFApY7UqJNIspFMu02018X6HTBGsNOd81X7Vx7AGTZlgHW0fHGT/9wdXMzs05FkGcEMex2+DWDRhURxU1RJL6CmMyfF/xrHPOZHpyhpXLltNoNcCTtNsN2q2Eubm5RWCpFQLkAHt3PEihZw3777mbQAcUvQqeXChJDtlY7d6znw99/BMIKY9QDV1YC72ehbVQuo3sO0hU7WW+3uLDH/40d9xxJ61WiyzLMCZz7kAYtLC8553v4o+/vZmvf+0bRz3I4Foq41PjeFKxdMkQ//Hhj1AqFBGP0/fOTExPTw9SCqpRwKqlS6nN1ztn2n1/3/MwxpJpyelnn4xqZEjlsuUgCBbLwoXE5XBs3OHB2PXNZAd24kwZjraOLofreWRZsqjBakyG9BRaOznUBQrKgoyJ5/ud3pKLhJFwWdNMrcHE+CzbD06ysrdI3NZc/bs7+fGNf2R4fAbf9+jurpBKn7HJWYxOOTA+zOie3dTqdQKhyKMoKws+tD1Dq9UmpwStRhMrYK7ZZGlvNw9u38aKFSuo16bxo6JDXxeLKOWjtMbLl1ne10M+6mJ8ZpwVfb2s7OtnzUABozMyAfnAJ9OWogqQyjLXMpy5ZgUP7hvhRc94OqP1OcZrNTZu3sRcbQY/jKi1E4KwwNjkBC2Z0Wg3SOKMnbN1yrmQKIoYnpumWCzTaDXJlarctH+O4WadOEtpp84+KZ/zCcOQTDuO2HgzYboNu2cShsdrHBgeZ/zgFDlfMNTTw0ScEEUBK5au5WAzpeB1Myk8jtu4lgtPP4kg8GklMe0sxaQWT9nO5aHoD/N05wtEfkAYeARSEamQ0FMoEaCEA11inFLjAoDWSGfZHvoBQXBkst1KM9Yesx6bj5BBQM4LiAKfRDcxJiMxTTzPw6QG38tBhyJhlKUtFYKEXKGMVBFaeGTGMQTuu+kPHHfKM1C+hzWSICoQBr4LXjp2pgjSIj3AB6lCiJyxwbnPvwCL5Jab/8C+XfuJwjwf+OAV3PPATgzOsPPjV3wErKK793iWL19OWFrNcee9mrax/OJXv8QK/zGNXMFPfvIz5lttrE75S5a1gote+kJ6Vy4hSdu87pL3UKs3MB1LayEEcTvBGPA6Aoq1tMVnvnwl45MTT/71kaxes5QMw//88McIIXj3ZZfx3Je+aPGZBcjC2c88jfOeczG5fIlzn3cO7/3IhyhFRay0DmjrCarlMkJKhnfcwuzcNLm1mxc9/7LUsGDFrZSTv1204AI3qRXKgXKlcNCTjru2+t+UbyZN8MMIbTPituuzSKyTxzS2ow6gkR0PN6M1WIGUPhZJIjSVqIcpNcOSYgFExu6pGoPVEpuXdTMzX6c+M8v2g0327Z0BpSkGPl1DS9GJ4bbt+7j4+eexbcd29pOnriV7RxvEBrorRZIkRRUE65YMsWZokK2Pbuf8U56KyVo00pRC3GY6mcfLHBPc1CdRvSVi3WTT6l72Hqxx7MZBzjm5wC9vupOxec2ZfUVuHqtjDNSlRqUw2xI874xjWDY4QNaOGdN1zj7lRJK4QRRF0JojiEKyBKYadXplNzVtKeTzlDsbbT6LyecL1FtNerq6kVaSD6uMtw+StDICJSnlIhAe1raxocQTUPY7Ey3hc+twg+JYwkzc4imDEU87fh0nLellx/QMa5d20VusMlI7wGwrppJk7B6f46RVvQTtPNc9MuKmTlIR+Yb+Yok1uQpWuemaVMb1ZKTXYdYrdJJ0OEu6U564bFmYhCS2aK0dFeWwVc33krTrBFEZlQtpGfC1wLmkSjwZkREjlEDJPKHywA/w0Bid4ns5l31JSxiF9HRXeeiBeznlGc9GS0MgFF7kIU2GMAF+4COMRYY+WepsnxAZnjR4wodAYjzDmWecyJ7dwzxl0waualxNu9Xgi1+8EikNb3jdG+jz8zx99Up+c88Mv7/lNu57aCfvf/+7ufveu3l0zwF0lnEkq9AsHvLHW0r5GPPY7MlwzbU/4f4HtrF9+/aOUoD7/YXHpOyg55W/yBF7LKn6CZfV/PfXr+aNl3Zx+eWfcM9qw/XX/ujIx6wlVyziBR4/v/ZHvP5Nb2d+YhrjBQS+g/NUu3KsHlzHNz/yDyw/7SSWbjwdkfgI6XqT1gBiwRpGLhLysRKsJVILctj+YrZrsk7v2R49iB9VuuSSM8+1Uh5yfYCMLHO1cWa0I3ceZniXaUvg+wSeT+gLEqMJI59cGFKLZ5mdmyRtNTlQq6OTlBM3DrG8r5v5RputO3eybyqmq+zz1pc/h1/94U/MzbY47/QTuHXrVigM8rute1hWLrFj/zCbVw5RVtDTVaXgGRIMm9es5ZjVQ9x57x0864zzaDfHaczXUUKgazOUChETc01CJekul7j/4R3cOzLCK559DjMzNX7x+z8Sej7f3jqJ8h1Lu1j0+LcLLyBRKaVcAYkiFDFDS5YyMjZKuZTnkf0z7JtrITyfAyOTNOsN6o02OybGeUp/N9vHZ6hWuhmemgbvELAuNYbUGtpJ7PSLlO/kR7RGISh4Puu786wZzDHfSKHV5J5aSigUAzmPrkqBYiFH3JzGioiBrhxRllG3irt3zzHcbDLRaKGUYFkxx75aA6EUx3T10Z8rkA98rHSoad/38X2FJERJg7EKa9NOuq2IsxRtDMJKtM3wrCKTTrr2uocPoZxf/doL8HG+fS0seT8k8hSxkIRywUveocILpQJGp4ShT6AChPAwWYb1JJ4niSp5Jnftp9TbiydcpobnYYQL2Nb45AKJ8iUZC7e0dBLAWiM9Z3YBBmNT3v62f+EFz3k2P/3ljSwI5GE98oHPl7/6MULt8Yo3vm2RPOoJxZKhpQwPD7uQ8iT0CFjgJfqL2LDHni8pPWxnSni03sohP0W5SOH6SwCRToCkM6AwT6wY0NfXx8YlvfzL5Z8iacdkIkVSIOdnFEpFpJRcffn/4ZQXncfGE88mjsWi04kAED7YBCFcWXZ4lmSwCOMgClY4LFdiNcp0SjkFTz/1zP836RLfX5ioBWQmxRgPYxJSnTpJExb6S+7XMFSdsi4hTjNnXdNOmazNoOMWM0lCmmqqgYdWgn1js4yPTWJi2Dmf0NaG9zzvfH54y+0MhBXSqMVVv/ojLS/ChtPoZouDccqGwT6sbdNOM8bHm2zYuJaK8ugb7CO2muecdhYtmeDlivR6MDs7T1tYcoUCev9+1NAqTBCx6bhN3Ll9Dzfd/kfOOuUprFvZzwM7pkl0Sjnv8ZJTNvOCp59E0dPc8cCDVDcdhx8Yql4vu3bsZs2mY5itx/i5mC7lseORPfSUquzad4BizmNdfx87ag0Kvk+9VQOVYawl5+ew0nM0Dik52GrheQFpGhOWihSlx2x9npbOWDXUTW9o+dVDw2RGoEKfmXaTWhxxdk+Rft9yU82wbWqUaljGZDEoicHSaMUoz5VlM62YfJhjfVcvS6sV/I5ekvICbGSJ45jAC5BCEKcpUrrmrzYpqU4JlAdCIXSG1c4+KZQ+iX6MimBWBE9jpUFljk3uI7AqxvND4pagUA5RqTOVCIMQOiNjtESEAZiU/t5upibHqPYsxQgNUpFaiHxFIHyU75HGiSsblCIQcnEKnBpNELlyyxoXJJSJuPTtb+FLn7uyc3A7WBpSvvL1z7J66WpOO+e5HXswV4pkNmN4eJhqtczg4CBbt247akAQQjA0NMS73vU2tu/Yzxc+/+UjAonXIUEbY5+02buA+/lLAuHhy3TkRJ/s733mU58nzPu0kwQZBEQmwApDrhAS5ny++5kvcP7LX0TX2uPI2gHWtsEXCOPaN75vwBzyGvQ8ZyyLFI5x4DvJIxQkmUV5nQGBFSj5JEP/o/6hsCAFjUaDOI5dv6hDNUgzg7bO9UJYaJsMnSYoJfC9yB2yWDI3O09zvk47gyx1brdt63GgkXBwdIb7D8xyy4FJavMJZeXzb9/5ET1BhYnGPD/fOsmuqTqnnbKJ5vQ4qdFImTLQXaRVbzA/m7Bp7XryXkC+WAAMo6OjiLyPJAM89u0eBmnp6R4gabeRYUhPLmJ89CBhABe/+CyisMzlV9/Cur4C0+0pelTIx159Af09AW/+7De59sY7OeFpZzJYlCzrX4o2LY5bv5IsyxivTVOPG8Rx6hxI0LTbCWmzzcHpKUZnZ5hozVOWHkanHNdVpaw1vlK0rSFAUqmUaYqEyA9QCEd9yTJ0ptg9MkZ7dpb+roBKMUdBSEIhmIzbXL9thN8+cpDnrOhidanMfLPGVKNNox3TbiUU8wWW54qsLVXY0rucs1auZmmp4owB00OkXik9/MCBYtMsQ6BoJpo0A4QitRKtU6wxZDbDSoHnl0CbxeHHwgo9g+xYfecLEWQJmRIY7SFTRbEYoJM2WqauvNHgCadG6ZdAZjAzuo/6TAMrc+ALsAt9i45uvHJigtITTjDOZg7U2wHv+iroSClbFuoibTOOP2EzL3zec49UXpAed9z9CGc/9wUApNYsjvULXsh3//uLfOmKj/KWt/2NM04VcNVVX+CTH38fP/jelYvjbdERtotbCZVCgec9+3Te+6+XHvFutLaLGcWi2Wfn14svvvjPzt9jEdx/0bE1T5xNOfcgyRVf+gLFSkAQOrlpQYb1MvL5AELJdz50OWdc8BQq609CixJGZq4PiOp4OXpoLAiD5ztcmDZOocBIsdjQB3cJS08gso6sive/nL6104wsPSTopo3jvy1gkqwReEqRWfCtdWL0QpJpx4aOkyZRGLrGbZbQ19uLJxVpnKESaEtJO3PKAjGwb6ZNPdP88Pat/PD+PTSN4IwT1/D7W+5Fa03ekzx140qm5ibpL1d55tOPp9JXQhVzHL9hPYHRbNywnlY7o9rdTxQKuvu6CKxE5n3CQoF2okkyGJtv8NC2nQz0DtLTW6Ia+Vx543aetWEtH3rDM7j1oUdJpjTf/v/eyctf+EyG924jKPXQ21UkF+Q5MD5O21r2jU2QtjX1epODtRkSk1Is5hAyz3yjSSHKgcrTTGKOHVzCjtk6p520hkJcQ2jDZGseaeCkVceQZgk6TpivN8GAEW1WDxRohhFrK4P4mWasmTDZ1ghjacSah2ba/ODhMYROaBjp3r9109ChQoWVlSq9+QKB73cOrssmhIJ62mamXmO+XcciSeOEehzTyhIyNJYUjaAc+kjjFAYKQZFKvkqoMpQXuAzqsJXZJka46YzWGhUoJJYw8pGhezb0fKexhUcYhlhtkVFIu6nY9+idLFm+gWaSIHDmmUEuT6YFhTBHaH1s6npGYZRHEyJFiEQQeB650OG4PF8iUQSBh0WTLziE84tecf4RgVRg+PR//ufiQTlcKuSdf/06Qt+n3NvP6pWrXPZhYezgbtasWYdVTqrHGYdKNqxewne/9ikKuZBm3GR68kj7qcOnd67Mc9PrSy75aybGR496UK21RFHkfBEfRwblyZbTRZL/l7P3DrPsKs98fyvsdGLl6qrq6pyDpFZoSQgFTAaBx4ABcz3Gw7U9gMEYwzDGF3sExvYYczE2xhiPsbnG5JxNEkhCKEvdrZZaUufcXfnUyXvvtdb9Y52qlgA1fryfp//oqu5z6pza6ztrfd/7/l60VKxcvQqhJFqFxNqhnSBA098XMH3HYV71phcT969BysLyUVP1tGVSSp/TCBhnvOegt6tTvQIlhINALhMqpPC6Ri0kytmfi+N58nXRfVQYhqSdLjpUZJklDmNMTzZeSKIepqQXudPt8WusV3YLGRIXErJuhzTNqfb3cX5m2ht7jaO/VKDV7VJIFK0IUmcw2pBnXv9QVjGXTw5w8uRZssxQiQsYA/3SsGXHNk7NzWHDiC2r17BYm+fsmTOsGhkkVgGqKGk2a8g8pb9YxClJLiXlcpH+SpV6t8Om9Wv58nd/wqUbN7F1fIipxUX+7Udz1FREqbnIrz//mfSPjnL/g49Ra8yxe8tmBleMs/fHt1ItFkj6B2l0c/qShHPz8wyVB+iOjSKtIVKSw7PzVCtFWl1LlhtOOTh94hzVWDE902bLmgnyswvUOppuNyUyOdVCmYVGHSkEYRhy5VgZHVbZPjmIDCSr50a579g0B0+dZ77eBCFQOE7X2xgLfTqgUohQKqA/ChlKEp9KshSzTUDbtAiCAC0DYivItTdbttuGKOilIDtNJBxSKJQUpMaiAuH9cTiSOCBvZchAYbpPbVrKMEEphzUSrcE4fzOHGb6BX4hwRlLIFVmQg8gJw4hytcTJQ0+wavtV5NKhggClLVpo8k7em7oJUuEQztGRgjhLlxepdRHGSVTe9ZM35zlDUikwnpgqRYhw0fJOCPxgWSKXx9bWWrSKWbV6BZe96AZaJmf6zHne8Lo3YXsLpq86wvTsInffd/9y36hUSnjHH72J+cYCSaHEZz/2eT7x7W/93HV1QfHsEOT82qtfys03v8bbOy6yiwiCgG6nc5GwrZ//XEJ4X9vM8ZPcdNMziJAI5VCEIB1JQVCIE/LjXRiY5nRtJRMTE1ibo3uhktZYokCRW89UEs6SK42wkkB6M3GWZd4DKyTGgNABYe5IFSAdpqeWUr/gFVxcPLmUdCkU2BRcTpYZiknBF54eCldLQRT4KZ1zDkK/k4p0iBKaMNI46yjrCJwkjAXdzLOXRRCie2hRgaJjMnILQjqm5zvUu44dW8c5e2aGhk3ZccmlHD19kmfv3kXHGWzWotVpMDgywmKrTb+SdNttTDejMXueqg4pjlYRqWRuappEKWYbDS5bs43vPnqS+dq3efNzL+HKdWs4eXqO512/m2a7zp49e5iYXMnU3Gk2TawmHBznwbtuY+uGjSycO4MMNUFXgVDesrI4T7fVxaVNrrpkB7W9j9KaneOSFcMsOsdDR0/TTD2u9cDZU1yxdpKr1q7hs/fuJYwUR06fZDHN6OZ+qilczoG5DudapxBacMXGdeycdDz30i3cdfA0+x4/xcHTM5AbnPABnmEUE5AT6oSC8vaSOEzodrt0TEYsMz+aFQJjc6SyxEJjrSJzPoEmVhFBoGh1ugRBL1rJZtjeeFcHmm6nQWpTIln8Gc1JoEKE9UJIpWNC7b1ssZA0nUcNkOEAACAASURBVCbMMlRUACVRJORKMbFihKmpcyTDwyBEj4Uk0AICYVFxQO40TgtshpcCGAPaA+eEFEhpexPC2DfTZY4QATiDEh4ZJ4TE5Dkf/8Q/8H//xhu9h9PYpywRKTXve/+7GRsf5KMf+Rg/uPVHvuhhCaVibOVKoqiP//bbr3/K0WrN6ErassIbfvMt/NE738pNL302V//SNbz5bX+MVIpIF0HldDqdC1414K2/97u43E9AW91Gr5AsnzoJellvQRDxxjf8Ns957gt5y5t/n0cfe2S56DxtA1xIhBJ88J8+Rn+1yMR1z6MddHxj2hpEaJExEMUM1Uvc0biTNZt3EwZFwPccAT+EkdL/TL2dkM9OkUjZ63sJRaj18s+ksGAglxbpJFJ5i4kS2vcI/7NFqdttA94hrpTC4igmBXJysjwjjgs+cDDPEErSbeUESiOU9A1I07OduJDcpBQLVdKshZMROoxQnQClFPU0Jerd3IO6RLPbIbcOLQXPvGo9EkeRkEKhwMkTh9kwVOXUycNMrljF+cVzTA6sYLa2yOrJQeZmTpLoBJtnxHGMk46pg8cY2baRxtkUpKDeSkkTyXAx5qHpJvuPnUNE53nZ7m0cPvEQq6NhKkmZxx47woGT8wz0T7IubbBz82baC7MMTa6kLiTz56ZInUGHAWMDQyw0H6fWMpzdu4eyijmrFQ9On+fqvj6uXVlhT63BlqDIlnUDnJlbZGw0AOWo6hhHRtd0vUbEOXCCKFCUk5AfPXSUX77hSoZLMYeOn+FZG4apn58ibfTRzboooQjRpFr4T0Hh/LG6B+0OAwEyRIqcOIgxxuf3LaXpBoFGqWj55u6kGUkQ0cy7GJNhcYRaEgQRuJw8z4lUj2f0U3dQ0zlK+GamT7TJwEWYICTSDiVDH0qqJTbPqZSHuPP2b7Nuw+Uk4HdDNiMu+OKSg9dJabDWEEQJQlqQvoCIHgHVOocwCq3ACYtS9MbtEqk9+B9pUZHAysBD1J6ylmWvyFjCQPHo/uN8/wc/fAolMXOWP//LP+dDH/pID9lzoZm8/8gTvPl1b0QKyb998ou84EU38pzrr+fj//xhTp44x5qxAj+45xH+5Z//7Snv14tvfh7ttEsrTz21odebomcAzq2HKcrccvDBvbzoJTdzZurMRRf18uUsYwODnLlnD6teeCPtoINcKihKY12ODio88Kkv076yn6HiGsJCBZk67zd0PdFjz4R/4Yjri2Zmjd9YCIEUXkyrxNL75UXVsldicuOHEiZ3vhl/keui3w51RBAEhGHsRZLOb8Hyjq/ctcVFFhs1ulm6fH7MbYaPUzK00g65zXxiBgHFYkIhKTE5tooVAyMMDY3QX+pjdf8IYwOjjPQPUi0WGCyUiYIQJyQlZajPn2K+PcPwRD+ttMX8fI36YpuGtawaG2ZuboZSDFPnprBplwOPP8apszNEUtJq11h32aXMHz9FlmW4ULP/xFFsM2V8QKAcfHrPacpWoWyNLfEQf/WDn/DEufMEqo9dGyfZOb6Cdr3GsaNPEAQxaRBirfWTIB1RLpa8bibTVAt9DA72U66ErKgUaNc63Hf+PIOlfn5l+wZMINl/6gw3bN5Mt5XzW8+8lOGiJLeWYuAxJVb7n2u+2ULpkGuu2MieQyfZf+gI/bHizPkZtg2WMGlG20namaXdc78bp1Ba0jZ+O11rN2l1PbLE9hrWwku7e8cVPzldGjmL3uLrmi6hdH5ylQtCJKbT6SXOWBabDW//yJ76qReJDKcDQu1RKkaGqECQ925wIQQZOQpHnDVpLy6wZtV2XKDIVUJXGJIk6XGZdE90F5GanFAGRCZHWTBWgvD6OCEUSvoPQuMsmBCTB0ghyIXqJbYoMBZtAmSW8eWvfOqnbn8PUfu3T/4f3vq2d/Cn7/1T/9XeFEsIQV+1zMzULPfdfZdf3D+1Q/FiecuxY8f41Kc/z/nZRQaqBS7ZvglZ7GfP3v1PKXJOCtrtGons8q5b3s7uLVt5xq4djA5Ul/tGA5Uqr3rFy/nClz7L6972BmJped5znn3hMS4iE0iShNe/7U0M7d5KoRAjnOxNI/2Rt1BIeOQb3+SSZ07SECOMTG5AmRwVeFd/ECqEdL2+Egg8nsRZ396PtN+JStXTLinPUfPR3RIh8L8P5/dV1vzHZBUXLUqtTpNms4lxXqXd6aRkaQenHDY3RGFIqVD0UwnrCMOYUqnSK2Qhg/1DFOIEWBoZOi8vMI4wiAl7iyGIfTS0yXL/okPF6HA/W9eNM5zEaK0ZrJaYKIY0a03mFhqkMiEqBbg0x5outVqHwZFRpIhopYbRwRJRJSaREZac1sIiCkGUxDSbbZIkQQYFLh9Q3LBpmGIxQkvHWz75Q46d7BBIxfrVIwwNV1g0LeZnz7Nycg0d24W4iCZERYK+wYEeX/kUMnYkA2UWWi0WF5qUsawcrGCcZv2WlSRhxLOvWsWvXH8DX7vvblaPVDk2dY7nXX05z9y4Fu0E5UiwolJi/egAlwyW2TAa0ScySsUK852I+4/NEsUSBvtpZnWk9ZonIQ2hd9rS7lpcmqPCiHaWkxpLOS5ghb+J8zzFImjnKS3T8hYH62hlGUJ7Ymc399O3ZprhAsVcp00mRA9HEhMGJbrdjM5P7cQDHWFVlzAICLTwyFQkQShJggjnDKEImT14AFfpR6KxUYhSGqkchThBSkmaWSLp01adyhHCkZKTK4dUjjhRvWOo7AHx/M0eBSFBIAmU9hxxuYQJEQRhiIoDdBBR73a5ct0qtBIs9Y1HV/RTKUbYXIG7oBGyFnSQ8Efvege33XYbQuqf7f04/8fhdzdztQ6j44PMNZu8/S3v5DW//nr2PrTvqUXEOXAKKQYYCqq8/U/fzh+862289X/8HloJoiRkoBjzW7/zOoZGh0h6+JdXvuRlF13USz7VdrvN+//qb0hMTm4lOogIopCAjEpQ4OG7H2B8+wCVNZezZvPOXl8tAATaqafgd60zCOkdHaKHWvHDeQ1O+d1pT6+0pO62RvQwzQIV5DhhCSON/gWK7l/IUyqUiljjf0FxHBLqiCiIfYMsiWi32zSbTTppG6yj00mp1Wa9InqxTrPdwRkfSeOMJbeORqOxHHa39Mkhei52I6FUDHnuVRM8c0cfV1yxneu3beD6zVsp9xXZunEDUanClZeuo7nQ5us/vJO53KJUzqq1k4SlApdtXMvoigFmTp8kVZJ9d97F8NAIubAkUcyxMw269TbKwYlGSrdpOD19HtmVdIXiX/7gV5lcMcRjx46xYniM2dnTjAyNIUKNkBFZq05tcRYlY7SWFHSI1iFbN2yi1WrhlKQaSSZHh7h0VZmbt05SiWMI2qhCP4N0+O8veQ5Zq4lLLUdOnWDHlklefsN2EqXY0l9msCRZvXolykFUHiI2LSbGCsxmhs/84BA/uP8Az959GYmGShTR6TowOQ6JdBYZKRSGRAviwGugcmtoZxYrFQZDIAWhiDBK0Eq9j6zZ8akmSRhhlWMgCklUQCn2RlstwJoucaQoJAGB+im/V2aJiJbH3mEcQS/nr5PmOCdYsaJM/4adpC3jgzuDEOMsMgjI0tSHmPY+aZ0NCGRCrCO09rtn43qNVEArRRxIIpX0yIcGh1m2Pzx5oS7t4Jf+vOfDf+aPYfjC9O5b/phbf/Cj5YKzdH8KLNdeuZkt2zZz7733/sdElLlhcWaGvNkmK4Uei/tT/R/hIE1zuq5BwzSZGBimGMZsXLWGHcOjpJ2Mm1/2X5BS0XWO+myThVaTqfrcxZ+8Z7YONLzv3e9l/ZpNREp76kMvhWhsrJ9dO4sk0TCYGBldeL+c6xWdXk850BolQ3Ce/KmejFERtoeK0f4ov6Q+7x37cpvhpANCL760thdq+vTXLyBPWvI0Iwl989OfL/0uqdnwwHVrIYlisswXmVAokqiElBCGmmISe6ZL5LUrCEEcRphuShgIgoKm3k6hpNi0apBSIrly00o2rO5nzepBjMzZdNku1q1eQb8UZMJwybY1VAdHGBsssmvVGq7ctImd27aTNxaZHOoncx20VKiwyIo1k5yemiEqJczO1eg6Q9IXcd/D+/n1G57BsZai1pzl7sOLnDjb5DPv+K+881+/xMpVk9xw3VVUQkNULHDXw/uQxZjCyApMmiJ1iJGOWAgmJ1cztnqS6alTFIVlamae41NTHs5V7eeay7fRatcZG1vLidMzLMZlFmo1XnDd5Vy7cxPWSB7Y9yhZlvGK63bwnGu28Ju/tJvIdjlRy1k8fwrCQU6dm2P3ynG07DA3k3HbA4+BEKRpjhF+wTsMItTkqWMxy0npcbAyyFNDIQCR+76FNRqtHMpZqpUK5UKRQDraLU+ZVEKC8okqyvjfL0qS5l0W297KY8VTb6ECEaGxIA3WKJRKcRjiQNPpdDj86P1Mne0g8wwVSWwmaaeCQCiskYRCg1QEYUzaFQgFeZYBBikdSixNyhwqVOggIs+8ejmQwvN7VIzUkqzro8211r3/L3vUxYAwKDI+vovffukNvWIBwjo+9OF/YkntLZTEGcsXPvdJ/uAP30Xecbz1936X/0BNAuE4NdXg9W/8Hxw9dARtwuXE6KXLAZXBERZqKUJUOHLoJIv1FsPVMu/+uw/w/J2X0FxocvLQcR57aB//9Nf/wEixnyuv3H3Rp3bOoZzj32+9lXXbN/kCIoWfRArL1Vdfx2N7v8nBE9NUxteB6pB37XIhX94oSI8ettaAM+hAoHrGWoEvSksCTycs1oCTDqcd4OUHWgbkCFLr8wYNPrThYtdFi1KxWATrSG2KVhGdTkq73WauuYAOfCrr0tk3twYVSBaaNdqdOu12k3a3Q7PdotluYa3EGkMUOE/UU35hmHbGro2j/NbNl/JLzxjjf77xev7b772GSn+RuH8YqRSNxiJBJSFtLLBucICxtaspqZyH9u1FVxNqtRrzM6e57847mT5+lHy+hulkJKWEYigYHBvjwLHDzEcJdOu857W/Qr3bZdO6FXzwtTcy3YETNRhYu5K//+y3uGn7Zr66/xjVvpjp89Nks012rl2HDEI61pKnOZkzzM7OMrcwQ1JQxNYx2D9At9ulqhSrxiYo6pB6Ljhfm2M0ColCxfOuu4oMTf/YJPsfe4LN4wNcu3OUs+emOLj/NFMLC3z4K3fwBx//Dt975ATj/f3c9cQct93+A8Kupb7YpH90CIGkr9hHJS7itKWUFOgIL3zEOi+DSDMSFdDJM5aiohEK0ZskeWuQ7y+l7RbOWLKOoK9aJABcbkjTDgZDoVikr9RHrCKE05SiBGWhEDwV8taki4xDnFUImSOMpqBilDXUa2e49NLrMNoghIbcIbRAyRwnJEplRGF52ZEflkOcM0SRIkPjjAAliYMCzkbYLCXrpugw9BMhqdBKgUvxGWnCe7V6/SalBFI7kiiirzrAp//ud3nur70Oi+VXb7oRmacYcWFhYx1bd2wil9BpN0Abjh09fsHztVR/nkY39K53/Qk5AixkpMuSA1QPoAbc8Z3bEVrxZ+/5Cz75qU+zf/+jdKWjWC7wO+/+f9h82dV86rNf40d33se3b/8Rr/zlV3JueuHnPt8SvcPheO+734np5LgUr8IXAqtTSpUC937zn2m3Yzbuei6BDhEuQBFgrSc7WOuFkc653rFYeE9ej15qnPU2M2FZQutaaxHSM7YCApzNMS4ndRplAeu85lGaC6PFp7nULbfc8rTf/NbHP3lLrbOIQiOk3/o2u11EBkg/IxDCklnvGNZS46TDGMhMThgEy3L5VrtDlmUYZ0nbKQiHCQM2bx7kWbs3UB0pIgoxpcFV1OdniEplXLdDqCWVgQFy06VVb5GYDnEUMHvuLOWowsMHDnH+3Bkm+yqUnOX+/Y+QZx1k3iEuFtB9g8S5pTXfZee6VZw6e5rv73+EG3Zfwb/fcw9Xrhxn7WQfkxXBlvUTXHfNs7niOZezdd0YRx55lH2nZ7l2+xaivjKFaom5hUVmz5zhtvsfoxAVCIUiikA5QavbppCUmJo+z8qRftJUYrMuW7dtY9vmNdSnZ5htpZw7fYKNG9czPjzMPY88yspKP6tWlDk9M8exqQUip2k4Q2wNl02Osn7VKCcXMqbOTjHXnCPtOJyI0DLACUfqoNXNqCQhIvfaHkVOOS4QxzFKe26zsT6xWCpLJ8sJdO+TzDjCUHvGs0tJs5wwDMlyi9YBaZYTRyGtTguBI/doCAqFItbCI0+aBu2+fAuiECOM6LmkQvr7q5z/7r0kW9ajZYgVAh1plBJEKkBHHvGrZYnUtlAyRDkQUkHgIf3SBmit/OKR3sIkpPSKYiRCBkglAYVzftqmlUIq6RdLD+0ai4C+oWG+85n3c+WzXkOuQ1732l/j5OFzrN6xiTv+/Tba2QXrzKa169m+4zLu/sndrBkf5+1/+MdPWSNSyqdtNv/015c0Q4VI8YGPfogdl2zjoTvv4y8/8EFanQaf+cJXiYuaKInp5m3u/P4d/K8/fQ9BEHDbbd/HYVloNcil5tF9D/28ZwTn+PZt32d0xSpv7RCCQPvJ65YN2/mX976NsfXrGN5+DTp1OCnRSi4f2Yz1U07V21U6K0A5pAxx1nPflRQIPC7GOu+TlNJLiJZ/EtFrcCuLxBNUg564WhnHxMTKdz9d3bloUfrs33/4lqhQJFaabtqhXm9QiBMykyOQWGN7I8sA6SztTnt51BpGvjPvnCTLcnRPXl4t9ZGZjBueuYlnX7eeNRN95K0F2tZRSIqoQkKxb5CZqSmmp2eZOX2CSqFIUCyCtRyfmsKkOX0a2vUaI8NDTKxbw08eP8h4X8RYaZhz7S4nZ6bR3Q4VHdM/0U9/KeE9//xFrto8yXNedjPfufU2nnvFFXz06z/k/PnzaFng6ptfTGf6OG+/5aO8+MarMO02E31DFAeqNOfOkRPRyTIfTWRAmxZCSSKtqZb62PPIw1QrRTo5TI4PcPDIWUaH+kiKEWQdtl+ynbt+fCfjY6Pcf+AhdBBz+bZNxANDREA10hyttejXhnO1DuNDJRrNLgdPnqPb7oDTTNUdadORWq+SVUqRdVICpXFSedlQICEXhHFImqZ+uOAckYI4LgBQjGIEvi8YRxFCGOqLDdLc0tdfxZjUT2twlAsR9UaTIIiwxqK0INAJ7XYDrQSPTp9fvmeuvH4XBR3R0oKgUqT5lx+lb+8j9NUWWH3XHmavuxrtMoQOCQPP7A6Fxjrtb3aliMMCqWmideCLjhUorXrH/xxlA6wLfFKr0iA1urfnF1ojhfRFWEqk87snpT3iZN36XXzh0+9j1/WvRBCgIkGnk3H45FHGx1fxxS9+8Smw2rn5Bl/66hfZ+9BePv25L6PUzxah/6jC2jnHunXr+MeP/RNJ1mb1yAjv/eu/WS4IE2MrGRrpxwlNt5XxjW9/j6PHDzMzMwU9gJ1A8/j+PT+T+7e0Y/nkv36MQlD2zX4Zo5REyJShsZU0T+ynPFRgbMs1hCLEST8QENIXL9WjRuplFEkOBH6dZ8ZLKoTH+ZhepLhUXpnuen1/qzymxDrrNzM4UAFK+Omm8+NeJsYn/nNF6Rsf/9dbTG5IOxntTptCIfGCKunPh8ViiVKxgOjJ51XgOTtC4QVaAsLAg+RBorXqYRlyVo0NsH33diw5c6dPEilB1ulSGCpTjjRSK0pDFaK4wvT0AvPHTjI/v0i3m3Lk5Gn2HD1FEAu6Bob6ykxPL7J1fIRj509xZr7BxPAE23du5vQTj9Cab7BYb/CCq3byt9+4l12rilx22fXcd+/9rF2zkr17j1GTlh3bR3nrBz7Fu37n14nKgocfPcLk+FqKlYAD+x5ncssWtFYYayhV+3n80AG0sPSXikRa8vDhE5CnFJMS56fnuPORx4lIMWmX3ZdfStpeoKALPHbqBFesXc1VV1/B5776JUTeYcVoH2sm1jI5WsWk0LQGmQdM9g1Q6ziqUYWSjhBG4hKNyiGMYrQOCFRIJ21T0gFCOAIVIKQg1D6zyxqf8Wasj9rOsow4inECFhoNr1USnhggA02z3kQrjQXiOCY1foKnhCAKA5xTpFmHQPuk4oMLs8v3zPXX7MQYTUhM8BcfphAH6N6WfxGHPDINl2whQoOGQGqybk4SRVjnhXNGGHSgkEr0Jlp+DK20QMnQO/gDH1zg7VwS7cBJhbM5Uip06H1qgcxxUhIaw6aNO/noB97Itc95LUoKpBJo6YvY2IYJPvLHf87ZhfmniCnzPMVZi3UWrZcawY4oLGGsD2flP1iUtNaEYUh/dQRhU5L+Mg89sIf5+RoAURywbfvlPLr/AA/cv49vfvtbPrrsSU8hhA+qfMrjSk8ouubSS3n2L7+EKAgBgRYGJS1RLPny//47oskCKzdfBUQIKRCyVzyUX5cAQa/n5e0wIPBsJakFgfYAPpxD66DX2/N6tyUjrkIgvWUWK3xz3WLRzvcntXAY5/7zRekLH/nYLUIoFusNb6wTvtB0shScNx0sLjYxxlIoRFiTE6B7HG+/fa7VGuR55iu2g07aJSnFXHPZJMcP7WVAKvKsSWN2ivnp8xx79CDz56c5uH8fp584RoUWrdlp2mlKo9Ngx4ZVrFs5zOZ1a9i2ZpJVq4d5cN9hrtyyihMnj7Pn8Ek2rN9CVIypFkLCVpf5XDE6sZIf7z3EyqhNMW2xYedGKolmuBjw/Ku386IXPo/99z7KK65Yx94Dj5EkJcZH+oiLEjNXpzDcR3l0lG6tTnNhHpt22P/4UaK4TLvVQKuIRSfp76tSry1wxbZt1GuzHDpZY9emVTTrC4z397N11yY6tQaf+daPUY1pXvhLV3HlC17A7OHznJk6hZYh3c4C+4/OU9SKeqdJQcZkSpHmDl0oEuTgQs+0ytpdcpujhcTg7Skms3SF/55xnnGVG08RtRascGSZIQoCQq1ppW26JifWmkApAh3QSTtUKmXazSah8DdgIYyRQeDRvvgbNssyDj2pKF1z/TUs5k2Sv/lXwnJM6dJNHD5zjnoP07Kj06bWLqLWjy8TGy2aMHCEOkDrEGslTjh/zwiFED6owLocIUDroIf+8PoXbxb1u4UwjPwIW6QERFinwQmy0PLZv/6f3PzaP+ylwSwdvQAEBR1SXTvGrd+/k5/JIu9dSwpuKSVvev2vccufvJMXvPDFfOVrX8ddxAi7dAkhqNfr7H14D6949a9QLVa55LKdfPOb30EIwdGjRzmw93G+973vs2fPA7Q7reXx+tL/DwTYnxqp92C7/MV73k3fwDC6V6wdEUpYdm2+DjE0T6l/A3FY9XRYKwDne0W90b63gPVaPsKTDLQKcPhwTB9EoJBCeeGlVr3HAUevPixTJpeMua7HuBLkJkdILwOaGH/649tFZ3NCSrppmyAOKYQB7U6KE5ZYC7JUEpZilAowxlGvt4mThKnFOSqFCg5DmnpFd1IIaXdTlNBeOrCYk2hBMjbKbfc8wFBSZr45h45KHDh8ji3NNgOjg5w+foQvfWuGLav7UCpjfGSY3DrIMuJKgVRozGKXWHf5zLd+yOXbNpOUqxgBl25ZydSJs5RWVLnv1n2s2zTJquESXdlPKR7knq99l7F1o5w6cgxrc3aFirEBTVCMueK5V5PPGfL5KfY//gSpLfCMXRvoLMzRWJhl9uw0AwN9DAz0sXL1Bo488TDWnmBl/whrNm7ArFrHvXvvY/uGSQaLBX50/x5WxAHN2jlubO5iw6o+3vyaZxNmMf0bNtM9e5pINtg4GrEwM8ejGHavGWDv8Q6VRJNZP8qd77QYkA5rJSZ3BKEiCDQoEJlD9AyvQaAgM5T6+mi06kCOcQIpHFp6pbeVgnbXY3dlGNBtZUhlCJ3fHbXzlIV2G4thsdEgSaDeCegLNHmeU4wSZuZmCcLkKfeMVW36P/p5VKVCw7SY33cMEDRMRk7AwwHYB79D5dk7CLUit5ZyXEZrvNtcetuHFqARGCsIA7/whPA78txZwkCglSAIFHmW9xKbwVqH1tIL/XSKsgmVYoV//9xfcPUrfp9Wq4FwJZQ2y/1OIaDTzdi6aRvoHJ4eQwTA17/8BYqlAjXb4Y47vndRZ/6Tr6Wi9qEPvI9YBbi8zeTk2LJUwBjD40cf8eLDXnqLMZ6TPTfnZQBf+s7XeenzX/qUI6RzCi1yRjduRZN5w6sQKNnhql038eM7P4Eor6BcLCMkmB5sTeChbV6P1KMdyF4BJCQMe/HovUa1F0XCUk101r93fszfkzsoiXHen+joOQeEuFCs8Faki10XV3QHAThJKSkgtb8JdOTje4PQn61bjSadbrc3uu1SDAtIZZmbm/OiNiloNZt0Oh3mFmsYHEkSc26+xV337WfPviM88PhRSkkfrtsliWDeag4fnWK0upL//Y7f5JUvey4rVm4iJeHE8XMszNdZXGyw0Ozw8LFTzDccr3zGDoQ1vPyGq1g/GLA4M0c5tPzVP36Vay9dzcMPPMTjBx9HVsuMbh1jYtskX7nrIUpRQnuxw+GD+6jPN2jPL1IUknvuuYcf7T3M2ORato0rshw681PIUkJBKoZKVbTLMek027ZtoTI4wezsLFG7hpQd1k6upL9U5b/ceCMbVwywc8Mkyjh+9OADHNzzGN3jx4nNNK2DB9j3w7uRKsIQURldxQ2rxzkx1aaQRISlCtVSEeEMI0lCKUqICgmVYgFrMnJnIXM4EVDQmoFqH61WCyEctdaiN0sbi3Qw3848JQCBtI40tzSyDG0Ew9UyWinaWeqDM0tlTKMJVlBEo2SMy5to7Xc3CwsLFItF+ipPLUrd9/0b80rRMCldJLlNSbWipEI6yqBcjpCWgwdOYDKLikKMcggDdC1ZDlqGaCkxtoegtTnC5ChdINARQmZ+p2Q9akVK6cmZWiF7i8qmltAZkmI/X/+XP+GGX/l94jAAEaO0P7L4HYXfdSWJh9F96IPvJ0Aj2vtc0gAAIABJREFUwictDd8/95cIWJyfIs876Fzy0X/8OD8Tfvc015K+6fCxk+TCkbuUvJMRl6PejlChHEitekp5/++XCpJQcOz0lCeAPqmp/P5b3sU999+NcBk5giyQhMKxfe02vvKZD3L+5Gn6kxECFSGcpwN4xbzBWZ8YLCWoXlSYFB6Mh5NYg5cASOff+16zfklrZK3vMQohENKrxJAa2VONL9tUdOB7lM5h9MW9bxc9vn3m7/7hlv6BAWZnZuimbSrFPs/GThR56j1xpWqFKIqZW6gRRSFCelZPJ2sTq4Dp5gJBqUjaaeJQlMKYMNakrkOA5pLNq5hrTnH/nkMcON2k3erSWGwRJwVGB0t86rs/4dY7HqYQSTZtnGDLjk2EUYHm/CwL7Zx9+x/h1NGTrFk5Sn/fAEkQkrou1jk6KWgM82nK1GIKYcC+o9McOHCGM4ePMtzfR63V4bFTDcb6qxR0jB7bQHO+wdZ1G7jyxs3UDj2Cq65Guw7nFur86HvfZaRS4PT0Obat28DJ81P0xQHVah833PgM2vOLuDylm7ZJsybnpmZ4yXNuIIkTiuUy9XbGxLpJdtx4HSKOEM5SrlQoD5YYGB7lX75+O9fv2sGps2eZbkuEST18zUFfaQCpLN0sJ1ABqTEUdIQQEGpvM1lstlBakZscFUfk3ZzMGCSOREWcbsxTib0hVqvQg+aET+Y1uUPjhYbtdpNCoYJRUEz6aLcWCAsxeeq3/JnIUUimZuY5Wp9fvmcG4sibfIVhDM1ZaUly/4laVCEtk3M4ywjXjrJyzVpILYVQYoVCBhFaWD/VRYG0SC09Xln4kbNSodfLaIFSUU/q4BAixEMyNaIQIl2LsckN3PGND3PFC38TazNCHSCkRWmNELLHR3LLwsogiKhUqnzys58mMtIvMEA50E7wyy9/EW9565sYnRgly8C05vn8l76Bdb9ga9W7lhriR4+dYXJsktwonJJcu3M337nzexRzuOnlL+Xo44d/JhlFKW/TuHLnFdx++w+8015K/uCtb+ZZL7iZuU6GxhEFMRGCtZvXc+TAfXTaNdbvusl/6JkLu5UemQp/wHryz+eW1ew+XTnvTS+Fn7b1sCuwBKJTGIdvaDvfUxJCgjUsPZw1xu+chMCQg1VMjI097fHtojjcV16y22klSK3D5imFxHOxu50mpXKVUGmCJKBd7zC/uOCbot0uQRjSaC4SxBF5x9DO25SLFYT1TJhutoi0gtXrS5w8eo6Hz9XIhKNfBpzN25hOzub+kBNtyXABXvvSFzBQqXLo8IOcOnuOdlNy2eUbadeb3Ln3cfJ6zvDkAK++YSe1hVkW5qfZsGqSh544yYmpJuu3beDL33yEZz5rIwtnW5hugqbNXL1Nx2r6S5JX37SJ7+w5RH//IAMVxZoV46wYynHlMSp9/czPz+GaHfY++gQT5RJTzTZPnDpDpVjg9PGjvOpFz6FcHkRXC5w+cJTRsTInTp7iwNkWhQh2btlABUs0MUaoJfOPPsSHbj3K40+c4I3P28buG2+ge+Yw0cQ4H//ybRx+YpauGiC1hsFC2TdXY02zlaGUTxRWPeypMzlhHGG6hkKlxOzCLKEKcVJQSYp0u12iKKDZ7nj8RbdLpVIi1BFaa86dO4NOEmyWUqn00W62sDjqrSYDAwO0Wi36yhVqtdqykrfZTekrFEjTlK8dfGT5nnmBClkThMTa0nJQN4YACICyDkhQPHrNtZS1YMszdi4bbJ0LCGWAUynGBP74IvwuKAw0xgQEoQMXIpVF6dBD5pS3Rfj+kyPRCfVum5EkpbYQYgoSHRiEjdBh0PNxeQ410pHnFxbZkniwrCOe9fwXY3pTMYfjIx/5W8qVKrMzM5AGjK6sEEYR//X/ej2tdgPnLv7pv1RYlkiN1kp++SUv5atf/wqvedbz+Y0/fDMH7n6At773Fm55xy3c8mf/66kLVQhu/8ldvOrlL/MgQyz/+P99grJ0DK9cheiB+qWE1WtWcvbo3czMdBlftxOXS2TglrG1Ty4qHt0ilr/uvIp0WQ4ghPB/50IwgH8NcrkoLeVAwgWJhHPOs6aWzno97Vmae63SVZftftrt5UV3St/+xKdvUUrSzTL6ylXanY5PRS0kOOtopz4WKIgDoiCi3elQKCV02h2SOEJYQX9/BR1EVEtlUuOnLCZVFEohp842UWGFviRCdXKScoG+ICZSmrrRvPSKS/nJoUOMD/Txz9/6AXmq2L5zK1E54YGHjtLKFJPbtvHi63dz7OjDPPTIefacWqAhixyZSrnv8AL7Ti1w5NgUE+PDzJ+tcXK6TSdTzDY7xIG/oVuNjIPnj1OpjJC2NNvXjTDWZxnevJVH7niQya2bOb9vDyKJGan0MdOqMzfbZPdlW+gs1tm5aTO6WyMvDmLTs0SFhGbbEoUJGyerrFkzTqebsf/0PAPJIHl9msLEekwrJ48jPnH7EWbPHKNZbzAz26LdMJxe0FSSEokOSAoFsiyjVKySZ12cFUwOjYKUFOKQbpajdUCedSkUEopxEWGhWCrSbNTRYchiq0kSh2TdLkmhSKfVIUkiFmsLWK3RQuKsJM8ziqWClz4oRbPVohDFtNttZBh475TSFKMClb4KzVaLx2enlu+ZcQUjOmJcCQ6hCG3KWFDFaEvFWA40GxTWbKE8WmJiaNjHvouYSCmEc2ROIwKHFKCURgcx1rqepyrwUUraT+N04Cc+TkmUEwQStJWMDJa4947vURhbRRT5kuis9QEXUvWOewpjcoSQZL3XuiQCbJuML3zmc0BIFGv+7O/fTxgIfvs338C3v/U9stxwzfXXcvb0Kb72ta/j3M9vjP+0VOBC/huA4+ixIxhjePjEYV71ildjQsGdX/8ed99/Px2T9gI4/WMrIVm9aTPf/vIXMVLxP974BnZcsoP+FcO4XCOUIwwsKoj41z/5I9asm2RkwxXLhUKIC4kpS/40ACv9tGzp34GHHwgJSvZEkVxILVnmcC/hV8QSNeBJRa13mUCBzX1ai3MYNIoMJTVjK55+p3TRRve5mXMMVPsYqFTJTIsoimm3WxRLiS9QcUC72yEwjjzLiKOAQhQinMQ6ELklzy3DfYN00w6D1QpaRfRXK3RNl8HSICk5Ji8xUhlFaEsxjBFCMbfY5Pxsl5s2XsmZEy0uH92EcTnf+vc9TLVbTHWaaDXLda0UXWtjo7UMViWdc9Pcu+8MuXCU4yIDxX4G4gILMzAyNMhAMe/9kkoorWm36lx51WoefuIoMjvHq27azQ/vvodzQnJtfxHikHOP7KVUGcR0clKp2LhhNfXmCQo6pNwXEWuQTpOkdQ4efIIwKLL+istIVkxy8MBjyHNz1DqGrRsn6JsY4Pi+o3RrcMPV67l050pecvU23vk3n+PkUJlixdKoZ0RxTDNrE8mQzKRYDPVag3prkeHhUY6fP8PY6ArSbpuBaskbmrsBtVqNcmUAJz1iJLeGvjgiUgFIr/Y2mdeX1Zs+3sngm+DW5SRRGZP5BWx6fPZOnhFpSRKGzCw2GO2vMjffIO206bSempBb0hFGdbFE9OVdykGBmm2BgnIhpn/7dZQqlvGNq8mkJVYxdeNjuXUUEOWG1IDsWUNIU08AiBKEzLynammtO098VEphujmBtJw9eYgO46y9/NnLzWLw4/glY64QYrkQeeV3tEyFlFIi05yv3/5NXnT9zfzjP/wtx544xEOPnewRVzNuu/0HWJfzwx/+cFm39PP8cL8I9J+mPZW3s/zO6/87H/jg/0vddChFRUQLcnPhWGicRXbauCBAp44X/+qrEVIinaGrMpxRLEQas+d2fulXX8jA1utwWb6845Hywm5o6WimlMLluWdYyQuvY6k4u+UwBkDYZXvNk0MClv6+VPCWdlnWQJg7cjTe7IPvDfaQNhe7LrpTuu0zX7zFSkVjYYEwjImSkCSOSDs5URJ4VGkQEekAR04UF5mtLeKMoVRMPMNXeZ1Jq9WiUilz5uxZwigkzXKkgnPnZz0OJEuxTtHpppyfnaVS6aPb7RBHilKpSJzENDsZQ9UhBotl1g8Ms3VsHJdGGLo8dugczUZKrSEYqlZZOTBK1nGMDgxQTEoUSgHGWKIoJssy2tbHVhsnmJ0/T+YMU3MNHjxwlKsuWctUO2RlX5lIZhw6dAphWkR5l1r7PN/42m2QN5maP4POW9y3/yBHzjaIdIG56TMM90es3r6O2VPniIXizMw0lSRk5ZYtPPrQPlZuWU9pYAi9Ypy7bv0JDx44xl+95ZU8dKiFDhPSPCWKCwgkg32DaB0ShTEpKcWkTKvVZmRomE6n1euLhEipwDmUlnQ6HYyzOKEx3iWAlJJWq07qDElUoNmoUyyVEGia7SZJsQDWUqstIEONNgJjUpI4pBAmzNRq6CCm1WwSRRHT83MUiwlp1uZI7YLt4YoArAkYjwK0U9TzDomWXBpV2X/ZlVBwbL/+ap8f6CRdBLESGOHQVuGUT1bRWhGKEJTCSd1bCCFSZ2hZxJouOgi89EQLAixPPHgfay+/jIyQUCqvxRE9lCsCMARB6M35zvpdl5LLam/oTYpCDW3DhFNUVm5gcHSU8R3b+fLnvwD4XUKr0aDTTTEmv6iq+xddlUqFvJvRqDe48ZnP48DjB5k+O+UHGFw4ammtkWGZv/nUR/mNV72Koo7IrJ9WhnlE6hb54T+9j5H1a1h7yfW4DJwTaBVceBxhl3nny6EEYul9CJZfy5OPs8tyBPSTtFJiuYA7DEuFPhcO6SQOAUJhrUFI6UWxcinxROCsY2xs/D+nU7r181+8pdloI6WlvthGCpidWyDLM5TSBNp/MstAIoSmVCyilMcfRFGMySyL9QYC6Ha7LC7WKRYTGt027foiqbEMVPtwGLSOEPjG2orRUc6ePUO5XEYKz3HOOjmlJCbNUwIZEsUxGI1QFowm1gGlpMpwfwWXOSqVMsUkAZuTWYCe5ytMCALv3XLGkjYzTs7WWNFfxkTDLNRbFALJ1PnzLC7MIqVmcLif8/MLrF2zjvsPHIdKxNqRUbZvXMedB85RrZS46vrd3HfPXoJChfuOzDNSEWx91mVMz7RQuWLntdsRJqZ/oERfoYAxgg/85f/hV59zBQdPLfDje55grmYoREWcU2TdBlJKOt0uWmsajUXybs783ByFpKfKLkQs1lsUCxFKKJJSSNrNGBud8J+sPWKAyQ3VahWhFFgoF8uAo5NnpHnKiv4R5hZnkSqgkBRo1pukPfhrp90Gpekrl3HCN8LjoEASBTTqLSrlMgemL/Cl1wYxAZIVMuR4u8bKpEjiBLc5jZ6osuvG3RjrkSSIkDDwIlCURAlHTs/RT4oTEuG84lhrXzyU9BN43esl+eBOw8n9d1AaHUVFI0TKYUVvIieWfFkebOYvRxAEvcK0hNvwi05Kheixp8uXreVdb3wHVz5jFx9/319wtrYIFmKtEK0GL77uKh49PY0zvoD8vOvC46tlXtWTL2stufHPN78wwyOP7kdqb4J98nHLWoXrNNiyaoTh0UkvMBUAlq7rMPv/t/fuwbanZX3n5738buu3rnvty7n06T7dnKYRGrpbIwiMphHQxBicqsBMmFyMqWhiblZiKE0mcQpioTgmlVLjqDVj4piKhsQhykVIDFOCIAkhTRACNE1D9zl9zr6v++/+vu/88f7W2vvQ8ZBkqlL8cZ5/9q61d6219tq/9/k9z/f5Pt/vhz/GS1/9MnYfexzdisWFQXQm8+sapNCbKsgYTwtAgOSs0jufnDeVY4urrd9P0zQEofKkXO05SU6Abts8HJ6z5Dzh1rQ3TImgcY5ASfb2Lvy+SemOlID5ckFVZkgRkXY7CKHodbvs7e5SFgXGeldcLRVlWXJ8fEyWec/64+ND5ss5RV2Rdrt0ez2SJGJ7Zw9bGmSS0jQNp7M5J5MpWkvyPMc5w9HRSVtSG+bLBVleMlnMyaoa8ATO09MpdblilA5QLqDf75MVC3QYkKQdTA0Wv8U+7Pf8/t2qoqozumlKURSknZjBuM89u9sY0cPUFRd3L/CppxZsX7nEf7q+4kOf/CInjebjnzvho//+M2glSXWfb3z0Kk888SRveu0jfPDj+7zzH7+Lb/mWF/Hr/+ZZmKz4l//q9/jr3/OTvOjrHmJeF3z2PzzDNJuTZZbZ4RyTHTMcjPiRn/0gi2nGzSNLr5eSFSsaWyJUglCaRZFR5CvSXpe6rtnd3cZay3w+R6qIsiw5PDphNp8QR316aZ/9w1uI2pDEIVESk6Qdjo+PkXiFhuVyjnX+4nJVw3Q+IRARi/mKMIkpqobQOaqmxgjJosyZTCaYxtEgUJHkdDKjP+xR17drdD+cCHK75Hfv32P+8Mv59Isf4hMve4hLr3gpr3r9a0BqjHA0znidrsKS1w3OKoyQrT6PxFmvFy60tw9vmnbUb/zjxhhirSiamqc+9m4e/KY/xHD3GnHkqQJCgrOexHsmyeE2iWB98JyA8wRF/7jHnu4TO7ziG15IdrDgj33vn8I2Agf8wi//Cr/0zn/Kd7/lh8BUZ2DuufhK62ovhyI3ovmbRfbmrEX7+Mc/jjHmNgvwDS6lJW956w/yksceJ0kSAqdQtcQZ+MCP/z2SaymXXvgqEiNbjSa9AaTX725t+LFeSTHGeGqBUMhzUi+mVYTYAOLcXjVJ6Xly6zYNaF1OpOeZaW93JZTESYFoFVC9B5yj/CpV5Z2T0mRJv9/HUBMlIVVTUpqG5WrFzs6IPPMi98cnE4qipDEGKVp5TKnp9/tcuXQZ01QcHR2zXOU8+eSTFFVOnRVYJHGk6HcHftUhCOjEKePxgIsXL9I0ln6/z+npFIFlNpthbUMYara3t7nn6n3IQDIY9nAYxqNtsuWKMAyJOxFYRRIHBIHXgNrdGRNF/vB1ez2StOMlfw3MpzNEUfPMjSPmVvO+Dz9FML6HaGuHz3/piFW+4n2fv8G7ntjnw7/zND//Tz+MGu4SDMf88s/8Db7/L7+Z7/t77+ehR/rsXd0lbyCIQn7j3b/Fy171cj7y0d8lbrpcubrHL//qv+B3P/hvqadzOmFCbjoEccJ0dkremhjGkfdU6/V65FmJ1iFptw9IdKuBfnB0SNxJ6Ha7IAKyYsX+0TFxkmKEpGpqmqokyzJqLI0tWayWRFFE0okIdEQYemmZyhl2xiNu3LzO1niIUQolIYq8ZHEYaoQzKC2YLRdc2NthvloSd3u3XTMfu3qN5eUX8E2vex2Pve5RHn79K3nla17O1W96lMzWlO1ag6Qh1gKrDAKLdYWXtJUOGThP7HMdrJFe5731rvf65X51KRwOePZ3f5NHHn8jWVYQhq2TiV6PpMWGvBcEwQZPWbcvqnV29oefzYFcJ5SVy/iev/bX+eV3vJ2uGrVmnYI//eb/iaKxaGn4E294va/W/3OH6xzu8iM/8iPcOx4QJ2e8rvNt0vnXfu0ffNwf4hbjEUKgmpoHX/D1BKLxKhBBiUgFH/rFf8wrvuul3PcHXo+RIVifcM4nRYO7LSGtp2PrZGyU2Pz++jPaYETwPB12/xmeLdtba6mxGOOQRiGsl8f1JiZnydW/tuDO1MmvkpSCEPK8vXtmOaZuSJOINE6wTkGgGAyHDAYD7nvgKiJwpN0EY2uEcFR1weHhIYvFimsP3k/YCbly5QoXLl1BIRj2uzinsLZi//AAoSRhHHB6OmU6nQKS+XzKaDRgazwmSDroMKIovM3Tc7duoJzh5s0bbPd2uXr5Ak0DcaI4Or7JxQtjMJq6LimruU+arfJzU9ccHU7Qwsv+VlWFdDHjnYsYqzAy5onPPMcnPz3l//nIZ/nisstIDvjs9QmfKwr+7088x7974lPYusv1//hZPvmFZ/nDj+3x1NPP8dHP3eD7v+9NfOM3voR6UrH/9Bd58aOP8n/83C/yzv/z11jNGt77sZvcqhKc8C2Yc45V2ZDoDrPlwov9lzWT0xm97cEGP+p0OigRQqA4Pp1Cq1GddgOyZc7ezohIOuqy8GslTnHx4l57oCVxGNG0+29JR6FDQWFqet0Oy3LFsDfm9ODI7y9JSRJ1CKTlZJnhakOelZTGcpovEVJzfHxy2zXTcxWv+ePfxsJ6V5HAapwJUcGZY4iX4g2RgaLbuq8kKkAHzrO2m1ZqVq4le33lUNclRvjDkBUrPvALb+fiY6/CVCVa+mXdpgaHQSoA35at7/BBEPiJXrvftT6c5w+kblek1o/rMOQv/a3vZ7qYeUKjcrzlh99KYzxX76lPf47IPH9etE4o69d+29vexg/+lb/AvWFCF/gj3/Y4guf7ugVa8urXf6s3xcQTKfec4wWX9whVjaFEYKmM5JPvfg8P/Q87XHzk23GrtnUS4nm8KYGlcmdV2nlagBDCm098xeOA35vk7O9Yt5+ePOnOWtNAE8nw7PnPJUTnHFJZbwYizlyM7xR35Cn91dd+h8sK3zrJpmEwHgF45cimoamMx320AOszZlmWBIHfMp7OFly8eJFbN2/SG3QRTlLWGWVh6CQJRVlSNyU7ozG3Do+49uADLOYrdCDb3y1wBqqmZLnIaBpv+dLtdjDGEIUaoQPquqYuK7a2hsznGXVdEoZhyzJtfb/ihG6ckJclWb4kCALmiwVxFLWTCIEOErQSqEBQlhXLRUaSpEjhqK1huZiRdvtk0ymD7RGf+dJnmNfwt7/7Nfyj33qSP/h1fT7xxBdoenv80Uf2+NdfmGPzhquXNEk+I+z1effvPEM32eKe8TbLbIVSigbnLbTdWQldFSUniwWDKEaH3idt0E0oS6+xXVYVVinmp3MeeughlrMpQZxw47lnSboptm6IwgRjS6IgJIwTTk+PMbVlNO6zWKzIVhWXLu8SRRFfePqL6KDDqlhycbRHIXP6QZfT+QyrBNUq90qPcYSykm6cULSGEe/93Jlt99/6ge8nCR1NpIhFgo4DpAURCBqLxxpthTASG0RI7VAywhkII42lxrkIKRuEDRDaa47LFkzF1VRC8Zl3/Ryv/FM/jC1yrIRItQRLoQgChTEtQ1k2LZfGg9vnq4j1wTlPKFxXUV5TukKpkNI6PvPRf8bP/eI/49nrGSII+LEfewdf9+IHWM2P+ON/+i9iq5qvFu/9wDupspJOp8Pi5Igv35zzQz/0N58vravgG178Up7+vd+jh+AX3/8+ZKdDqhS1ceBW/OrP/EPe+L1/lEH6AC4dEemAumnOtI3OJZ0NEVJZtDk3ecMAjqb2XUrTNM8HuaXAmdtF74z0CK1zXvAxjHzit85Bq1JbW4fUvrp2znk5XrmuBh2Pvuyx35endEdKwMHJERpJJBSVdDgDs8UUHcaUeUav16NpGu65cImTkxOEkgzilPk8w1pIuwl1VTAcdhEiYDFfMt7Zpow9/uQag+7E6G7Ctd79HNza9+1i3dDrpZRlTlnU1E3J9vY2YaRZLBaEOqJpCmQQspgtGY0GLGrLKvfVxGQyYWcnoWksgWzIsoxQSU7KdnUjiEmShE7a43Q6Iel0yPMVkbMsFpk/JM4RRQm2KkkS79oiK8NkMmUw6pEmPa7uXaMra/6v3/gs0jQ88ZkJp4uIe2PHO//fp+gCxy7gi89M6XU6jNOIa7v389zykMJ4u6N6mZFsDymygjBOqasGGWiCMObFD+zy5RvPMkiHnExO2dnaY1mdUmY5vShBd2K6UcLN564zHPSII0Ucx2AshTM0qxU74wFBHLG/f0gchhhpODqdsdXtMuyPmS5mBIuCa/df48vXv0waxRzMjjy2kViqpsLg2NvdpchzTk+mhHHEtHSkUYj7isMYpRG1hACJlQ5XNOh+SNOAlg7blGgV0ISSINQ40x4cJf242EoCLXBCIcMAYQ3OOoTyvKVrDzzEr/39/5WXv+lvUJWWUCtCLXFCIp0Hw31yF0hpaBoIAk8tDsPoNuKfP3zrydvZGTGmQSlarznohIYXfeub+aFI86M/+15u3rzJh97/QR586CpBPMRV9fM4OutYH3bnHMtZxaDfwyGQyYjJ9EyHap0kA2v5wEd/B/KKxXzOIB2ThQ0d5yhsgwpL3vfjP8+3vuFRhpceRroAiaaxNVq3NtrqjDvk3JkTr24rVePWHCO/WHverfd8hWMkhAjMuq1D+FmbdVglcG0L7JzDWa9qKVolgXU9JKSmMhWSpnXRUYiv4kZ5xzpKqwgZx/SGA5IkYVEsicKEThxy7doD9Ho9jDEcH004Oj5lVRYUWc3Ozpg8K4i7fQ4OT8jzmlu3biG15HR+Sqgko50RFy9epJeETI6OOTo+5fLlyyilKMqa2WxBFEX0BwlR6A0bj48mNLWlzDMvbl8bhls98jKjwdFLh8RxTK+XEoYhURSxXGSUVrLIcoqqJss9kHg6nVEUBaoRzJcLpOpwPJ0gVYSri43muJWCk8XCu3vGIZ20R2Mk08mSwbBLZkPu37nItSvX6MQDLu/ey7wQJMGI0iXcO9hlJ9km1X1mq4qJqRjGA5wVpGlK7QyiaoiiiEhrr1UUBJRVTm0dVy5fIggUvV6PrFwSioC69HyppjIcTaZsDUeYRlCVJVhDkeUMw4h+v89iVVIVJXlZ+521LKOjQk4mxxRVjqsaoiggX6xI4h6Vg2tX7mPYG5LVJXlVI6xkvszZ2RrT7acESLpRhzSMyb4Cb7CyRgmNFG3CSHwVJF2IEwqhAowDFQqveimdV53Ua21nA3jHEtFqakvlD1FelPzGP/k7PPrH3gzSoFo1R/B38A05EYGlPQCilT1pnU7WlahPAhKl5OYgCOU8YIv3S1sDvnUFSW34wuw6f/l/eRNShLzi21+NKgqSsM+e8jKwGl+Zi/YZpdSbhOR39QSD/ginJXVjePuP/ujmFDrh26z3f+gD2KqgrHKGox2cbuhKgdIQx/DAPS/noe98KRcf/cMIkyAJEdJjbA6zITiudfW19p2CdXXrau1ljp31FY8mtdXYAAAWaklEQVSQXgXTttO1xlRebkT5lRGz1in3WY7zluOBH7P5drvlJxljUEISBAFYQ1VVaNc65fKfx6j+q5JSp5Ogccznc3q9HgGa7fHYS5AUBQcHB/T7feq6Zry1hagdVlrm8yUXL12gWM4JAs3uhR36WyOiUHJhtEdv0EdZT6mKox5KSLppwvXr18nznF7aQ+uQLMuYTufESUqgHYN+yu54iyRJSHsDsA1lYUiiLlcu7uJM03rUBSyWGXlRkPRSv0lvHXXlpSCiNEEqRV0VyEDSC0IGvXDjwuK0pNNNqZqarPBWQzcPj5jOMzqdLs45kjRu8Spfepflit3tPbqdhH7aJY00460dlHJc2t0hiWIuDscM45ThYIumMdw8PKAbxtRlhW0MB8fHxFHHYyISJtMjnvriM1hrOT4+5uhkCtJAIGiqnFv7+wy7KTf2b3I0OWL/6JgkSdm9sEfRJqEk1hRlRi+KsAh2ekNKDXFvyCLPUErw7I3rZKbi4PSQQEj2jw4ZdmIeuu8BdkdjdrYHFGXOZ59+mn4cE6YRKtDUjWUY3g5bRqrrrYx0SNY0zCVU2i+41mgaKbBaIwjRUngraeEvVGMzcBpEjNPe+yyIpH8sibn+4X/Cw6/+cxgTgFtzatxmvK21bjErAcYvDnuRM7sBkc9PkJyzG7zEWIE1wrPGvXkcSobe/juIEVJzZfsl6HSfX/31X+Fvv+V/Y570OT6Z8HO/+Rv8/Z98q3eAtZ6M6BUNzqZozjk+/5kvcHx6istqTr58HaW93MyrH3uUX3/Xr/Kb/+ZDGAKaQhEEA4SsqaqKpoZOJ2X/U0/z2+/5CR58yavpholX1tRe8nf9GUgFzqrn42b45eM1Tifa5LI2J/UefQ4lAyraSsqtJ5ReRcC0raFEIKzAtV55Qgft8/g1FycsNQ2IABS4Fh+zSmBaNYT/5qR0cHDg5WuLitPTCVoK8twrEB4fn3p3k1DTSQOEMCglGAx6hFHE6WSCqT1z7+R4wlZ/QBDFnM6m3Lp1C2Nq4k6CVIJeb0Av7dLv97l8+QrWmY0/WRiGKOW95+qyYrFYoAJNUdXegKCpUEqQLXOm8xlpmmKMIe0mOOcte2gM2+MRo+EOdeOZ0QBB6OViZ4sly3y5cbkQUkNj2d4ak0QhZWMYDHrESbiZWhweHlKbhqijiKIIkNRlQyeN2d25QLc7ZHs0JIhiOp0OV/cu0UtiAqk4PTqmrEt2ByPGFy56Bw5hGY+3mE2nmKpkOs8QQUycdiiqmjRN6fW6nJxMGA9H2Maxs7OLMV4bvJekaBlQ1x5/q6oCKfy0bJUVDEZDlFKkvQ40NYM0JpIhMu5w5fK9SCm5/9I9XNzeJQkjVnnG/sFNnKlxVcP2aIvBYMCiKJhMJhRZRmUrFq1A2TpqVaMjRSMCdBjRQeCcpaq9aeca06F2G2GxumklVUXUJgyvkySEAhdimopPv/cfce0N34eS3n5cqvC29uR853R+erQBsKWmqc/LlYhNEltvuIeBprFViym5DVgd4pnt3/j4Gxl0LiAqwZ9747fxtjf9eT5x8CV+5u/+NI99w3fwE2/7O6h2nSOIQi98th6rO8fP/tRP8+Rnv0RWFJAGXBkMGJiGt/3vP0WYXMIph7a61YQCcERxQBDC5cvXuHCPJHCCUfeyf07OwOnz/CIpPdh/G9O6jXU1I4TA1s1mR81aT71wGLQT3D5QlBgBde3PZN163smmNZdoLBi7qQo34L0zXmFACECinfA2YF8l7piUrKkp84pOmhAGEqkV12/cJM9zhJQ8cO0FHB4e+h5eaDqdLidHU4R17GxvcWFvzN7uiF63Q7/fQTnF5XsuYIyj2+2z/9wxy2yBxHF4esxiteTLzzzLfD6lqWryPKcsS64/9yzLVc4qW2Bx1HVNURRordE6ZJEXVI0Hs09Pj7lwcYu6MlhXcXR0RKebMJnO2d7epciX6I6XbpgtphxPpgzG2yxnS0ajMXXVkGdLpA68/U3d0B8M6HR75HnOdD6hqBpqJ1gt5rjG3+2bosSZmqPjU5566mnCUCNFzbDTQStHmAYsq4w4iuh2uyRxyP7RIdPZKYPekFBHlHVBHEbMlwVCOvpxh8oZKuvQaMosp99NwRriRCKsb70a41BJQhKFCKcpqxVh2GGVVX6qGIQcnEyQbdtqjOF0VdI0DbKp0IGlzmtqa5DCYCtv/W0NqDBAR5LZbEYErLKC3mCLvKlYFiWj0fi2a8YgEarlqwiHaQTOSXQc4aTbrBh4fp9vNUIdoJxASVDSbrg71jqqpmQ76LD16KvQq4LKNFgBSpZttdPcllwAvwh6rs2AM0B7Dfo65869jmc1N43xmJQ90xZSSlEph6GkWmYcnRzy+Q+9h2/9k9/Do19/iV/7m2/ltz72QV77+CtYNX1+8K/9FSJnqYqS4CumXPPFgn/wk+9AWIkLI773B/4qH/n8p3DOEEc1Cd7zrpYOrRv6/QGjUZ9uOuCf/8Lb2d+/xb2v/E6MKXHubCJWluW5VReH14Hx4PUa9F7rJOH8/0cK4RUrhcDJ9c1fbRLZeXsq6UBLSdBWVd5rUGC1n+gZBKEMCYK2WvXmTChpkfKsYkPYDS/sTnHH6dt3PfSIc9YyGPWZz5ZcvHCBk5OjDafIWhgOh8xmE3q9HkJ5+5VstbiNx9AYb9EipR/P0zI/d3bGHB1PGPZ6LLMFk+mCXj8mCuLNJECpAICiqckXU+677z5OTmZEkWI6nW8urrUUr7UWpKOb9nGu8C6rjaHT6eBsw2q1QliBUQJTN3Q6HU4mpwz7PRaLFaPRiMViQRCFHB8egVBEoWa8vUu+XKDTmOduHtDtdAhCRUeFVMKynM3Z3d4hLwtc6/3eH4wQrma5XCJVgMVx6+YBg62R792dNxzo9lNq01BZAVXle30jSLopxweHDLZGBMpr2DjbtHISGoEnXO4fnBCEilBq5kXBznhE0zTs7+8zHg0xxtEIf/FevudeDm8+RxiGFHnFcLxFnufkxQJrJEkU0FReKGywNWIxXzEYjZhOJyjhN8T7nZTT5RzZWIJBl/f83n/YXDNv/btv8fKpyjtaSKeRQYjQAbJpvJOHcERRgDWSQGuvaqogCmJsW/0IWWEawUfe/Q949LV/hl5/hziMfEXkZEsfaK2DaNnaTrZrE3LDTzojTsLa9963NmfJwuMl8gwAF3azK3ee3xNoQaYdX/rQ+3n4m7+L+fSEPNL8x9/6bd7x9p/kYm/A677zDXz9q17B8uhZLj7ycp78yEfZftkVfuEdP83D20P6993P17/im7l27aWYnkJUjijwU7VIaZRyOBoGgwGmgTjVvO+XfoqrL3qQB17yGhB68/7W73/91Vi7sUBaUyoMjkAIaM0lpVy3tQpja/93o7AShDtzMLGEXqXB+RvIunISwuN15+kUUjhqB5EM/c+swGBQwtA4UK3CgH9dz1V69GWP/L7A0p2T0gsfdv3uACMMZW2QWNKkS1XX5NmS4daIoigo8ort8Ygsy1itckajEUGkvUspbNqiqqpaI0vhQWap0YF/b8tsxXA45HD/CCmh0+kglCQQitPpBJAEYYhU0FR1uzFuyfO1zGtDHHYo65LlckqaDoiSEIkgSSKevX6LQEs6nQ7zLKfb61BlNVGoWCwzwkh77GwwIpSKsi4Ig5hVtmB35wLT6dRXHcr73CEFy/mK7e0h8/mS7d0dvviFp7jv3geYTI+x1tLtdjHGMRqNyPMFWdHe0aRX4vMOwTW1adAqZjadMtzdplpmdLeGHO4fMBwOKVdLsqZhd2tEtszRoSIKQpbZCmugkyRMZqfte3csaksYeHwgn2eoSCGsY1XkdHsDqjLHlIYoDVguM+Ik4Z69yxyfHKKikKYoCZKYg4MjLl24iHB+wrbMi82hnh5PQXudoQ/eemZzzfzYj/+wt86yCi1bjENJlPOKmEqEOLwsSRi2NuVGobVC4mVwhXAUJucLH3gXf+B//IvUZoqSMdYaAh0jtPPXlnUIJduWRbVJyWyIkptDZC1r/SRrW9VFsXbwWLvgtvbywsvDrpPSeSkOGQaE1vGJD/xDwvTFvPCVf4iTbJ+gVGgd0ljDL/38T/A//9m/wH/65Ke4+rIH2Y5HlMuS7mgPqQw0JSqMcJEkJqC2Bi19cg0DRRKnACgMIuhy8un3sVisuPBNrych3RBMb1tdEb5Fts47ijgMgsBjWgIvjevOSZfIs+8RBislAXqTrKypsYQIaWhah5QA6XfbjEO2u4hKe4su5zy4bRHe980GBML653FiI1vil3ItwsEjj/z+SemO7ZvTksP5hMODY+qiRKJIophOFJIXFUpIlAzopx3CSKJ1yBvf9FrKMkcJTVX4DXItFctlxuHhIVmVkS3bHbjVgizLKIqCMAyZTaZsjbdBNOgAlvMZyyxHhwFBEGCaxqvfKcliucQ4S6cTE4YhUmp06OntaTogLzOqomS1WhFGKUEQsr297XGmKKZYLcE1dDpdZOhB9729PYb9DlIpnLEEWjIcbLFazinyFXES+kowLzmdL0jTiNk8I+11+dIz1+mOBjgq4rjDaDCkcl49cDabkBU5pnFMlwtm0yknp1OOZhOy2l+k3TRhvLNFN4ypmpI6K0ijEFs3JEmCMobpZI5zhtIJTuZTP82SXmFSRTHzxZS8aYilJ4QWee6TuxHEaYetwZCqKrBOIENJuSx4wdX7McZx82Cfk+mE/ZsHVKZhPl8yGAyYL6ZURc10OidbFXS7XZZFyYW9Hb9pH9/OKnG19/cT2ickoTywGeoAKQVCefZ2EATeAcMFCAHG1Ei8MmaeVxw++QTXXvcGbHOCFbHHdsKwVTk808p2nOFG/h643hXzigDWnu25wVmSWYPemy0O3S41t1yl9SrKmtMTBAHaSkptefjxP4ss90liwVZviBPQ2BKk4c3f9wNEyZhXvOqbGaVXCMIe/cvbyGi9VOspE9omlMiWT6foxIowDj0QLQRGSv7de/8FZROw9ei3ENQJRjSsPefWk8F1O7rBwYRFKA9cq7ZdvW2P7VyS9W1dgHVqQ81wzuGkr3QMzltdrbG51nm3wiKUpDlnUOralvjsc2uwGGw7aXNCbHCurxZ3TEqmtGz1Btxz+SI7OztUrmaezcnrku3RFgcHR6yyBWXdsH9wgNbwzl/5EFVVcfPwgOs3b1HWFTcOD4migLTTR2tNb+B5N1euXKbb7VKXFVEQ0h8OyFZzpAipygapA8IoQjpLJ003/7AqKxj1e4Q6Ic9zlsspQaC4fv055osVvV6Ks37Uv8ozrj9znSQOOJ3MEELR7yXYRiBCf6DG/SH97oDp6Yzp6YLVfEav1+Pw6IQoDiiKit0Le3Q7KU45ok7CsD9gNlsQd2OeuXGdQAmyVcF0uiQI/XSuWq2YzieUzjFbFZRNzeWdPQIdcWl3x08ga4Fdl7ZCM1lO6cQJ1jUcT2coaSnLmv5ghIoUq6xEmRpj/ZKzk4IgDNE4kjDA1f4Omi8XqMZRlTk6kGinyFdLlIMkiej1emzvjrl58wambqjxgmlBmjBfLNA4qnKF1pq8qYg6Cd1eh5u3DoiiiJuzE0b9wWb6uA6rJSoMiZW37hY2ohNGniVfe1VSJSOsrTcrrFpqolASRpqXvugxnv3ov+Tawy+nn44ROkVjkdIrJVpse1d2fsTfKgH4g+odR9brJcizhdh1y7auqnyy0e1Xvy/mD0wL+qqz5zGmwVqDFRbVSGQYUZQln3zPOwlNxfZ4QH+QopUgjRNi5Q9tJ/CutKoRhMpP45RSdHSIoEHZEi0Vw1EXHcRoEYJVyNDx1L//KHtXIi4/8jjdpOsJyuZsuTcM4pbuIDZVj5TKK0Aa6YGglltkrSXQEYjW0hx1G/itcRhhMNKnBOdaE0+lfOuGw1q8jVd7D6qpvDuylH6tZL26g0CqplUKDVHrhOYcQSs9bNWdE9Mdk1IURayWS7Lc6zbvjHbAKXb2LqKjkPF4jJQwGA5ZC4+PxjFaS+IgZDQcUuclO4MRWVagA8FqkZFlS0xt+dKXrzNdrgiTDllW0GQe6B2Px4SRJkkihFMsspzFckJZ1OwfHKBUsNF0UiIg7QxZzPxW/Whn5GUTlF+pGA226A9SsrxkvDVEKsX167dwSmJLQ5LGFEWFMc7zgfp94rRHbRoGvYSjkwlpGlGsKsIwZNjrs93vI6RjfGGX5WRGN+0TKM32aIumzpmerFgUGYPBiKv3voDldMKgE5D0u1zfv0kQhMxXSy5fvYfCNpjacjo9od/v4oAsr2gsXN7bRRLQ6Sb0ej26cZfd3R3KYkk/Sdkdb9NPUvKqRKgAdMDWzjZ5WdMdDLFxTNrzxE8AEfqyWyvFYpmzWJVESc8rgiaJn0hZuOeee6mdZZ6VTCdz8sYyz3KWq7zV4DHspCN0nDzPF15r3Woxr+/kYBqHdTlCao81UiNF4st9Z3F2RdNYljdu8P53/zQvev13syoDhKx9NRbozdTO40chWmqCwPvbw9nEbf39OgGBaydzorWgPtsn88nKY31rLErKM1kPX03ItoIC2zik0CilefTbv4vBboBJdnAyII5SRqORV2zQ/n0KaUBUyACU8oz1wbBHr58yGPQYDoceejCcjfNFw7NPfI5+kvHAI9+BcTWu0gjZoLQnRXqtI38zWHOTvMrBumL0SUVI22I+oa/andrgbuf34pwU1Nrh8LpNrpUaEcaincA5BbJd3jUQCQVWIJ1sDWnXlZdXAlAW/xwqwIm2JRaqxYkd+v8PeTKOQpTWgOPC9g6HBwcESnN0a58sy1gsl4RBh7IoCHTCbLZgMBghpOeuNE3F1vbYA2fWEscdOp0Q5wS9XsrO9phOGGBNTV2XnM4nWATT6ZT5rAAkUewv8mblV1PGW1tIrZjNlygpqU1N0gmJ4oQHHniAbLbi6PCQftJBBZrlasVzN/dxGObzOSfHh1y65yKR8jtVz3zpWZRSnikehvT7EdIZoiCm2xsw7PaIogTjDFlV01SG6wcHLJdLrLVEScyF8S5JklJbS3+0RZAETA5PybKM+WIBUYC1AS6vGPb6XNzZYas3YHY8pd9L2dkdUdR+/69cLBiOeqzmCwDC2E80yqIAVzOfzdBRzxsxTI59ZRjGlGUJVnDzxrNo4fk7whiWy4zZZIrFUK5qtPSJt8qWrPKMqqkJkoDldIYVsChz5vM5lfWrLzuXdqnzHLDMV0sCpYnjGBkplDEM+93brpmmrjGVr2m0iM50tbUHaI2zG0zCOedbb9Xlwfsuc5Q9x94LX01jVsSRxuDlesuyBCwW6/e4qhJrvej9ehdrvR5yPjlqqW5bK1m3L2vwey3t6pPTGaDtK6dW1sSKzeObyZ0VmM4Ohzc+xZO//R6U8+AtTpLEXXq9HoPRkG43Zbw1IE1iut0+3W73NlAdbh/RAwx0Hx0/SzncwVKBU4jAIYRmzT7P83zTjm2SS3NWfXjPNntbq6oQbSt2ph4JHhMMhUIZQSDkRtZk7S5ppCeG1u3unDdWq0EoGnVuwVnJjcyJT4geoxLWtNIuHsb5LzFZuCPQfTfuxt24G/+9487runfjbtyNu/HfOe4mpbtxN+7G11TcTUp3427cja+puJuU7sbduBtfU3E3Kd2Nu3E3vqbiblK6G3fjbnxNxf8HlIHBl8oVvSUAAAAASUVORK5CYII=\n",
+      "text/plain": [
+       "<Figure size 360x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "tls = TfmdLists(files, tfm, splits=splits)\n",
+    "show_at(tls.valid, 0);"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "And we can finally get our data in `DataLoaders` by calling the `dataloaders` method. One thing to be careful here is that this method does not take `item_tfms` and `batch_tfms` like a `DataBlock`. The fastai `DataLoader` has several hooks that are named after events: here what we apply on the items after they are grabbed is called `after_item`, and what we apply on the batch once it's buils is called `after_batch`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dls = tls.dataloaders(after_item=[Resize(224), ToTensor], \n",
+    "    after_batch=[IntToFloatTensor, Normalize.from_stats(*imagenet_stats)])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Note that we need to pass more transforms than usual: that's because the data block API usually adds them automatically:\n",
+    "\n",
+    "- `ToTensor` is the one that converts images to tensors (again, it's applied on every part of the tuple)\n",
+    "- `IntToFloatTensor` convert the tensor of images that have integers from 0 to 255 to a tensor of floats, and divides by 255 to make the values between 0 and 1."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "And we have can now train a model using those `DataLoaders`. It needs a bit more customization than the usual model provided by `cnn_learner` since it has to take two images instead of one. We will see how to create such a model and train it in <<chapter_arch_dtails>>."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "TK conclusion and questionnaire"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Becoming a deep learning practitioner"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Congratulations — you've completed all of the chapters in this book which cover the key practical parts of training and using deep learning! You know how to use all of fastai's built in applications, and how to customise them using the data blocks API and loss functions. You even know how to create a neural network from scratch, and train it! (And hopefully you now know some of the questions to ask to help make sure your creations help improve society too.)\n",
+    "\n",
+    "The knowledge you already have is enough to create full working prototypes of many types of neural network application. More importantly, it will help you understand the capabilities and limitations of deep learning models, and how to design a system which best handles these capabilities and limitations.\n",
+    "\n",
+    "In the rest of this book we will be pulling apart these applications, piece by piece, to understand all of the foundations they are built on. This is important knowledge for a deep learning practitioner, because it is the knowledge which allows you to inspect and debug models that you build, and to create new applications which are customised for your particular projects."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "jupytext": {
+   "split_at_heading": true
+  },
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.5"
+  },
+  "toc": {
+   "base_numbering": 1,
+   "nav_menu": {},
+   "number_sections": false,
+   "sideBar": true,
+   "skip_h1_title": true,
+   "title_cell": "Table of Contents",
+   "title_sidebar": "Contents",
+   "toc_cell": false,
+   "toc_position": {},
+   "toc_section_display": true,
+   "toc_window_display": false
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/11_nlp_dive.ipynb b/11_nlp_dive.ipynb
deleted file mode 100644
index 030c726..0000000
--- a/11_nlp_dive.ipynb
+++ /dev/null
@@ -1,1315 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#hide\n",
-    "from utils import *"
-   ]
-  },
-  {
-   "cell_type": "raw",
-   "metadata": {},
-   "source": [
-    "[[chapter_nlp_dive]]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# A language model from scratch"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We're now ready to go deep... deep into deep learning! You already learned how to train a basic neural network, but how do you go from there to creating state of the art models? In this part of the book we're going to uncover all of the mysteries, starting with language models."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## The data"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Whenever we start working on a new problem, we always first try to think of the simplest dataset we can which would allow us to try out methods quickly and easily, and interpret the results. When we started working on language modelling a few years ago, we didn't find any datasets that would allow for quick prototyping, so we made one. We call it *human numbers*, and it simply contains the first 10,000 numbers written out in English."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "> j: One of the most common practical mistakes I see even amongst highly experienced practitioners is failing to use appropriate datasets at appropriate times during the analysis process. In particular, most people tend to start with datasets which are too big and too complicated."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We can download, extract, and take a look at our dataset in the usual way:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from fastai2.text.all import *\n",
-    "path = untar_data(URLs.HUMAN_NUMBERS)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#hide\n",
-    "Path.BASE_PATH = path"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(#2) [Path('train.txt'),Path('valid.txt')]"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "path.ls()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Let's open those two files and see what's inside. At first we'll join all of those texts together and ignore the split train/valid given by the dataset, we will come back to it later on:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(#9998) ['one \\n','two \\n','three \\n','four \\n','five \\n','six \\n','seven \\n','eight \\n','nine \\n','ten \\n'...]"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "lines = L()\n",
-    "with open(path/'train.txt') as f: lines += L(*f.readlines())\n",
-    "with open(path/'valid.txt') as f: lines += L(*f.readlines())\n",
-    "lines"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We take all those lines and concatenate them in one big stream. To mark when we go from one number to the next, we use a '.' as separation:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'one . two . three . four . five . six . seven . eight . nine . ten . eleven . twelve . thirteen . fo'"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "text = ' . '.join([l.strip() for l in lines])\n",
-    "text[:100]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Let's use word tokenization for this dataset, by splitting on spaces:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "['one', '.', 'two', '.', 'three', '.', 'four', '.', 'five', '.']"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "tokens = text.split(' ')\n",
-    "tokens[:10]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "To numericalize, we have to create a list of all the unique tokens (our *vocab*):"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(#30) ['one','.','two','three','four','five','six','seven','eight','nine'...]"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "vocab = L(*tokens).unique()\n",
-    "vocab"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Then we can convert our tokens into numbers by looking up the index of each in the vocab:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(#63095) [0,1,2,1,3,1,4,1,5,1...]"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "word2idx = {w:i for i,w in enumerate(vocab)}\n",
-    "nums = L(word2idx[i] for i in tokens)\n",
-    "nums"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Our first language model from scratch"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "One simple way to turn this into a neural network would be to specify that we are going to predict each word based on the previous three words. Therefore, we could create a list of every sequence of three words as independent variables, and the next word after each sequence as the dependent variable. \n",
-    "\n",
-    "We can do that with plain Python. Let us do it first with tokens just to confirm what it looks like:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(#21031) [(['one', '.', 'two'], '.'),(['.', 'three', '.'], 'four'),(['four', '.', 'five'], '.'),(['.', 'six', '.'], 'seven'),(['seven', '.', 'eight'], '.'),(['.', 'nine', '.'], 'ten'),(['ten', '.', 'eleven'], '.'),(['.', 'twelve', '.'], 'thirteen'),(['thirteen', '.', 'fourteen'], '.'),(['.', 'fifteen', '.'], 'sixteen')...]"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "L((tokens[i:i+3], tokens[i+3]) for i in range(0,len(tokens)-4,3))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Now we will do it with tensors of the numericalized values, which is what the model will actually use:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(#21031) [(tensor([0, 1, 2]), 1),(tensor([1, 3, 1]), 4),(tensor([4, 1, 5]), 1),(tensor([1, 6, 1]), 7),(tensor([7, 1, 8]), 1),(tensor([1, 9, 1]), 10),(tensor([10,  1, 11]), 1),(tensor([ 1, 12,  1]), 13),(tensor([13,  1, 14]), 1),(tensor([ 1, 15,  1]), 16)...]"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "seqs = L((tensor(nums[i:i+3]), nums[i+3]) for i in range(0,len(nums)-4,3))\n",
-    "seqs"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Then we can batch those easily using the `DataLoader` class. For now we will split randomly the sequences."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "bs = 64\n",
-    "cut = int(len(seqs) * 0.8)\n",
-    "dls = DataLoaders.from_dsets(seqs[:cut], seqs[cut:], bs=64, shuffle=False)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We can now create a neural network architecture that takes three words as input, and returns a prediction of the probability of each possible next word in the vocab. We will use three standard linear layers, but with two tweaks.\n",
-    "\n",
-    "The first tweak is that the first linear layer will use only the first word's embedding as activations, the second layer will use the second word's embedding plus the first layer's output activations, and the third layer will use the third word's embedding plus the second layer's output activations. The key effect of this is that every word is interpreted in the information context of any words preceding it. \n",
-    "\n",
-    "The second tweak is that each of these three layers will use the same weight matrix. The way that one word impacts the activations from previous words should not change depending on the position of a word. In other words, activation values will change as data moves through the layers, but the layer weights themselves will not change from layer to layer. So a layer does not learn one sequence position; it must learn to handle all positions.\n",
-    "\n",
-    "Since layer weights do not change, you might think of the sequential layers as the \"same layer\" repeated. In fact  PyTorch makes this concrete; we can just create one layer, and use it multiple times."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Our language model in PyTorch"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We can now create the language model module that we described earlier:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class LMModel1(Module):\n",
-    "    def __init__(self, vocab_sz, n_hidden):\n",
-    "        self.i_h = nn.Embedding(vocab_sz, n_hidden)  \n",
-    "        self.h_h = nn.Linear(n_hidden, n_hidden)     \n",
-    "        self.h_o = nn.Linear(n_hidden,vocab_sz)\n",
-    "        \n",
-    "    def forward(self, x):\n",
-    "        h = F.relu(self.h_h(self.i_h(x[:,0])))\n",
-    "        h = h + self.i_h(x[:,1])\n",
-    "        h = F.relu(self.h_h(h))\n",
-    "        h = h + self.i_h(x[:,2])\n",
-    "        h = F.relu(self.h_h(h))\n",
-    "        return self.h_o(h)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "As you see, we have created three layers:\n",
-    "\n",
-    "- The embedding layer (`i_h` for *input* to *hidden*)\n",
-    "- The linear layer to create the activations for the next word (`h_h` for *hidden* to *hidden*)\n",
-    "- A final linear layer to predict the fourth word (`h_o` for *hidden* to *output*)\n",
-    "\n",
-    "This might be easier to represent in pictorial form. Let's define a simple pictorial representation of basic neural networks. Here's how we're going to represent a neural net with one hidden layer:"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<img alt=\"Pictorial representation of simple neural network\" width=\"400\" src=\"images/att_00020.png\">"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Each shape represents activations: rectangle for input, circle for hidden (inner) layer activations, and triangle for output activations:"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<img alt=\"Shapes used in our pictorial representations\" width=\"200\" src=\"images/att_00021.png\">"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "An arrow represents the actual layer computation—i.e. the linear layer followed by the activation layers. Using this notation, here's what our simple language model looks like:"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<img alt=\"Representation of our basic language model\" width=\"500\" caption=\"Representation of our basic language model\" id=\"lm_rep\" src=\"images/att_00022.png\">"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "To simplify things, we've removed the details of the layer computation from each arrow. We've also color-coded the arrows, such that all arrows with the same color have the same weight matrix. For instance, all the input layers use the same embedding matrix, so they all have the same color (green).\n",
-    "\n",
-    "Let's try training this model and see how it goes:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: left;\">\n",
-       "      <th>epoch</th>\n",
-       "      <th>train_loss</th>\n",
-       "      <th>valid_loss</th>\n",
-       "      <th>accuracy</th>\n",
-       "      <th>time</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <td>0</td>\n",
-       "      <td>1.824297</td>\n",
-       "      <td>1.970941</td>\n",
-       "      <td>0.467554</td>\n",
-       "      <td>00:02</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>1</td>\n",
-       "      <td>1.386973</td>\n",
-       "      <td>1.823242</td>\n",
-       "      <td>0.467554</td>\n",
-       "      <td>00:02</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>2</td>\n",
-       "      <td>1.417556</td>\n",
-       "      <td>1.654497</td>\n",
-       "      <td>0.494414</td>\n",
-       "      <td>00:02</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>3</td>\n",
-       "      <td>1.376440</td>\n",
-       "      <td>1.650849</td>\n",
-       "      <td>0.494414</td>\n",
-       "      <td>00:02</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>"
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "learn = Learner(dls, LMModel1(len(vocab), 64), loss_func=F.cross_entropy, metrics=accuracy)\n",
-    "learn.fit_one_cycle(4, 1e-3)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "To see if this is any good, let's check what would a very simple model give us. In this case we could always predict the most common token, so let's find out which token is the most often the target in our validation set:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(tensor(29), 'thousand', 0.15165200855716662)"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "n,counts = 0,torch.zeros(len(vocab))\n",
-    "for x,y in dls.valid:\n",
-    "    n += y.shape[0]\n",
-    "    for i in range_of(vocab): counts[i] += (y==i).long().sum()\n",
-    "idx = torch.argmax(counts)\n",
-    "idx, vocab[idx.item()], counts[idx].item()/n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "The most common token has the index 29, which corresponds to the token 'thousand'. Always predicting this token would give us an accuracy of roughly 15\\%, so we are faring way better!"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "> A: My first guess was that the separator would be the most common token, since there is one for every number. But looking at `tokens` reminded me that large numbers are written with many words, so on the way to 10,000 you write \"thousand\" a lot: five thousand, five thousand and one, five thousand and two, etc.. Oops! Looking at your data is great for noticing subtle features and also embarrassingly obvious ones."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Our first recurrent neural network"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Looking at the code for our module, we could simplify it by replacing the duplicated code that calls the layers with a for loop. As well as making our code simpler, this will also have the benefit that we could apply our module equally well to token sequences of different lengths; we would not be restricted to token lists of length three."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class LMModel2(Module):\n",
-    "    def __init__(self, vocab_sz, n_hidden):\n",
-    "        self.i_h = nn.Embedding(vocab_sz, n_hidden)  \n",
-    "        self.h_h = nn.Linear(n_hidden, n_hidden)     \n",
-    "        self.h_o = nn.Linear(n_hidden,vocab_sz)\n",
-    "        \n",
-    "    def forward(self, x):\n",
-    "        h = 0\n",
-    "        for i in range(3):\n",
-    "            h = h + self.i_h(x[:,i])\n",
-    "            h = F.relu(self.h_h(h))\n",
-    "        return self.h_o(h)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Let's check that we get the same results using this refactoring:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: left;\">\n",
-       "      <th>epoch</th>\n",
-       "      <th>train_loss</th>\n",
-       "      <th>valid_loss</th>\n",
-       "      <th>accuracy</th>\n",
-       "      <th>time</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <td>0</td>\n",
-       "      <td>1.816274</td>\n",
-       "      <td>1.964143</td>\n",
-       "      <td>0.460185</td>\n",
-       "      <td>00:02</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>1</td>\n",
-       "      <td>1.423805</td>\n",
-       "      <td>1.739964</td>\n",
-       "      <td>0.473259</td>\n",
-       "      <td>00:02</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>2</td>\n",
-       "      <td>1.430327</td>\n",
-       "      <td>1.685172</td>\n",
-       "      <td>0.485382</td>\n",
-       "      <td>00:02</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>3</td>\n",
-       "      <td>1.388390</td>\n",
-       "      <td>1.657033</td>\n",
-       "      <td>0.470406</td>\n",
-       "      <td>00:02</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>"
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "learn = Learner(dls, LMModel2(len(vocab), 64), loss_func=F.cross_entropy, metrics=accuracy)\n",
-    "learn.fit_one_cycle(4, 1e-3)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We can also refactor our pictorial representation in exactly the same way (we're also removing the details of activation sizes here, and using the same arrow colors as the previous diagram):"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<img alt=\"Basic recurrent neural network\" width=\"400\" caption=\"Basic recurrent neural network\" id=\"basic_rnn\" src=\"images/att_00070.png\">"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "You will see that there is a set of activations which are being updated each time through the loop, and are stored in the variable `h` — this is called the *hidden state*."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "> Jargon: hidden state: the activations that are updated at each step of a recurrent neural network"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "In `LMModel2` we only have one weight matrix, `h_h`, to calculate the next hidden state from the previous hidden state. Therefore the hidden state isn't able to easily calculate anything much more complex than a linear relationship. In next chapter we'll see how to create truely deep RNNs.\n",
-    "\n",
-    "A neural network which is defined using a loop like this is called a *recurrent neural network*, also known as an RNN. It is important to realise that an RNN is not a complicated new architecture, but is simply a refactoring of a multilayer neural network using a for loop.\n",
-    "\n",
-    "> A: My true opinion: if they were called \"looping neural networks\", or LNNs, they would seem 50% less daunting!"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Improving the RNN"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Maintaining the state of an RNN"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Looking at the code for our RNN, one thing that seems problematic is that we are initialising our hidden state to zero for every new input sequence. Why is that a problem? We made our sample sequences short so they would fit easily into batches. But if we order those samples correctly, those sample sequences will be read in order by the model, exposing the model to long stretches of the original sequence. \n",
-    "\n",
-    "But because we initialize the model's hidden state to zero for each new sample, we are throwing away all the information we have about the sentences we have seen so far, which means that our model doesn't actually know where we are up to in the overall counting sequence. This is easily fixed; we can simply move the initialisation of the hidden state to `__init__`.\n",
-    "\n",
-    "But this fix will create its own subtle, but important, problem. It effectively makes our neural network as deep as the entire number of tokens in our document. For instance, if there were 10,000 tokens in our dataset, we would be creating a 10,000 layer neural network.\n",
-    "\n",
-    "To see this, consider the original pictorial representation of our recurrent neural network, before refactoring it with a for loop. You can see each layer corresponds with one token input. When we talk about the representation of a recurrent neural network before refactoring with the for loop, we call this the *unrolled representation*. It is often helpful to consider the unrolled representation when trying to understand an RNN.\n",
-    "\n",
-    "The problem with a 10,000 layer neural network is that if and when you get to the 10,000th word of the dataset, you will still need to calculate the derivatives all the way back to the first layer. This is going to be very slow indeed, and very memory intensive. It is unlikely that you could store even one mini batch on your GPU.\n",
-    "\n",
-    "The solution to this is to tell PyTorch that we do not want to back propagate the derivatives through the entire implicit neural network. Instead, we will just keep the last three layers of gradients. To remove all of the gradient history in PyTorch, we use the `detach` method.\n",
-    "\n",
-    "Here is the new version of our RNN. It is now stateful, because it remembers its activations between different calls to `forward`, which represent its use for different samples in the batch:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class LMModel3(Module):\n",
-    "    def __init__(self, vocab_sz, n_hidden):\n",
-    "        self.i_h = nn.Embedding(vocab_sz, n_hidden)  \n",
-    "        self.h_h = nn.Linear(n_hidden, n_hidden)     \n",
-    "        self.h_o = nn.Linear(n_hidden,vocab_sz)\n",
-    "        self.h = 0\n",
-    "        \n",
-    "    def forward(self, x):\n",
-    "        for i in range(3):\n",
-    "            self.h = self.h + self.i_h(x[:,i])\n",
-    "            self.h = F.relu(self.h_h(self.h))\n",
-    "        out = self.h_o(self.h)\n",
-    "        self.h = self.h.detach()\n",
-    "        return out\n",
-    "    \n",
-    "    def reset(self): self.h = 0"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "If you think about it, this model will have the same activations whatever the sequence length we pick, because the hidden state will remember the last activation from the previous batch. The only thing that will be different are the gradients computed at each step: they will only be calculated on sequence length tokens in the past, instead of the whole stream. That is why this sequence length is often called *bptt* for back-propagation through time."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "* jargon: Back propagation through time (BPTT): Treating a neural net with effectively one layer per time step (usually refactored using a loop) as one big model, and calculating gradients on it in the usual way. To avoid running out of memory and time, we usually use _truncated_ BPTT, which \"detaches\" the history of computation steps in the hidden state every few time steps."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "To use `LMModel3`, we need to make sure the samples are going to be seen in a certain order. As we saw in the previous chapter, if the first line of the first batch is our `dset[0]` then the second batch should have `dset[1]` as the first line, so that the model sees the text flowing.\n",
-    "\n",
-    "`LMDataLoader` was doing this for us in the previous chapter. This time we're going to do it ourselves.\n",
-    "\n",
-    "To do this, we are going to rearrange our dataset. First we divide the samples into `m = len(dset) // bs` groups (this is the equivalent of splitting the whole concatenated dataset into, for instance, 64 equally sized pieces, since we're using `bs=64` here). `m` is the length of each of these pieces. For instance, if we're using our whole dataset (although we'll actually split it into train vs valid in a moment), that will be:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(328, 64, 21031)"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "m = len(seqs)//bs\n",
-    "m,bs,len(seqs)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "The first batch will be composed of the samples:\n",
-    "\n",
-    "    (0, m, 2*m, ..., (bs-1)*m)\n",
-    "\n",
-    "then the second batch of the samples: \n",
-    "\n",
-    "    (1, m+1, 2*m+1, ..., (bs-1)*m+1)\n",
-    "\n",
-    "and so forth. This way, at each epoch, the model will see a chunk of contiguous text of size `3*m` (since each text is of size 3) on each line of the batch.\n",
-    "\n",
-    "The following function does that reindexing:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def group_chunks(ds, bs):\n",
-    "    m = len(ds) // bs\n",
-    "    new_ds = L()\n",
-    "    for i in range(m): new_ds += L(ds[i + m*j] for j in range(bs))\n",
-    "    return new_ds"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Then we just pass `drop_last=True` when building our `DataLoaders` to drop the last batch that has not a shape of `bs`, we also pass `shuffle=False`  to make sure the texts are read in order."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "cut = int(len(seqs) * 0.8)\n",
-    "dls = DataLoaders.from_dsets(group_chunks(seqs[:cut], bs), group_chunks(seqs[cut:], bs), bs=bs, drop_last=True, shuffle=False)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "The last thing we add is a little tweak of the training loop via a `Callback`. We will talk more about callbacks in <<chapter_callbacks>>; this one will call the `reset` method of our model at the beginning of each epoch and before each validation phase. Since we implemented that method to zero the hidden state of the model, this will make sure we start we a clean state before reading those continuous chunks of text. We can also start training a bit longer:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: left;\">\n",
-       "      <th>epoch</th>\n",
-       "      <th>train_loss</th>\n",
-       "      <th>valid_loss</th>\n",
-       "      <th>accuracy</th>\n",
-       "      <th>time</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <td>0</td>\n",
-       "      <td>1.677074</td>\n",
-       "      <td>1.827367</td>\n",
-       "      <td>0.467548</td>\n",
-       "      <td>00:02</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>1</td>\n",
-       "      <td>1.282722</td>\n",
-       "      <td>1.870913</td>\n",
-       "      <td>0.388942</td>\n",
-       "      <td>00:02</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>2</td>\n",
-       "      <td>1.090705</td>\n",
-       "      <td>1.651793</td>\n",
-       "      <td>0.462500</td>\n",
-       "      <td>00:02</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>3</td>\n",
-       "      <td>1.005092</td>\n",
-       "      <td>1.613794</td>\n",
-       "      <td>0.516587</td>\n",
-       "      <td>00:02</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>4</td>\n",
-       "      <td>0.965975</td>\n",
-       "      <td>1.560775</td>\n",
-       "      <td>0.551202</td>\n",
-       "      <td>00:02</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>5</td>\n",
-       "      <td>0.916182</td>\n",
-       "      <td>1.595857</td>\n",
-       "      <td>0.560577</td>\n",
-       "      <td>00:02</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>6</td>\n",
-       "      <td>0.897657</td>\n",
-       "      <td>1.539733</td>\n",
-       "      <td>0.574279</td>\n",
-       "      <td>00:02</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>7</td>\n",
-       "      <td>0.836274</td>\n",
-       "      <td>1.585141</td>\n",
-       "      <td>0.583173</td>\n",
-       "      <td>00:02</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>8</td>\n",
-       "      <td>0.805877</td>\n",
-       "      <td>1.629808</td>\n",
-       "      <td>0.586779</td>\n",
-       "      <td>00:02</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>9</td>\n",
-       "      <td>0.795096</td>\n",
-       "      <td>1.651267</td>\n",
-       "      <td>0.588942</td>\n",
-       "      <td>00:02</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>"
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "learn = Learner(dls, LMModel3(len(vocab), 64), loss_func=F.cross_entropy,\n",
-    "                metrics=accuracy, cbs=ModelReseter)\n",
-    "learn.fit_one_cycle(10, 3e-3)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Creating more signal"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Another problem with our current approach is that we only predict one output word for each three input words. That means that the amount of signal that we are feeding back to update weights with is not as large as it could be. It would be better if we predicted the next word after every single word, rather than every three words. Here's the pictorial version:"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<img alt=\"RNN predicting after every token\" width=\"400\" caption=\"RNN predicting after every token\" id=\"stateful_rep\" src=\"images/att_00024.png\">"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "This is easy enough to add. We need to first change our data so that the dependent variable has each of the three next words after each of our three input words. Instead of 3, we use an attribute, `sl` (for sequence length) and make it a bit bigger:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "sl = 16\n",
-    "seqs = L((tensor(nums[i:i+sl]), tensor(nums[i+1:i+sl+1]))\n",
-    "         for i in range(0,len(nums)-sl-1,sl))\n",
-    "cut = int(len(seqs) * 0.8)\n",
-    "dls = DataLoaders.from_dsets(group_chunks(seqs[:cut], bs),\n",
-    "                             group_chunks(seqs[cut:], bs),\n",
-    "                             bs=bs, drop_last=True, shuffle=False)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Looking at the first element of `seqs`, we can see that it contains two lists of the same size. The second list is the same as the first, but offset by one element:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[(#16) ['one','.','two','.','three','.','four','.','five','.'...],\n",
-       " (#16) ['.','two','.','three','.','four','.','five','.','six'...]]"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "[L(vocab[o] for o in s) for s in seqs[0]]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Now we need to modify our model so that it outputs a prediction after every word, rather than just at the end of a three word sequence:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class LMModel4(Module):\n",
-    "    def __init__(self, vocab_sz, n_hidden):\n",
-    "        self.i_h = nn.Embedding(vocab_sz, n_hidden)  \n",
-    "        self.h_h = nn.Linear(n_hidden, n_hidden)     \n",
-    "        self.h_o = nn.Linear(n_hidden,vocab_sz)\n",
-    "        self.h = 0\n",
-    "        \n",
-    "    def forward(self, x):\n",
-    "        outs = []\n",
-    "        for i in range(sl):\n",
-    "            self.h = self.h + self.i_h(x[:,i])\n",
-    "            self.h = F.relu(self.h_h(self.h))\n",
-    "            outs.append(self.h_o(self.h))\n",
-    "        self.h = self.h.detach()\n",
-    "        return torch.stack(outs, dim=1)\n",
-    "    \n",
-    "    def reset(self): self.h = 0"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "This model will return outputs of shape `bs x sl x vocab_sz` (since we stacked on `dim=1`). Our targets are of shape `bs x sl`, so we need to flatten those before using them in `F.cross_entropy`:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def loss_func(inp, targ):\n",
-    "    return F.cross_entropy(inp.view(-1, len(vocab)), targ.view(-1))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We can now use this loss function to train the model:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: left;\">\n",
-       "      <th>epoch</th>\n",
-       "      <th>train_loss</th>\n",
-       "      <th>valid_loss</th>\n",
-       "      <th>accuracy</th>\n",
-       "      <th>time</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <td>0</td>\n",
-       "      <td>3.103298</td>\n",
-       "      <td>2.874341</td>\n",
-       "      <td>0.212565</td>\n",
-       "      <td>00:01</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>1</td>\n",
-       "      <td>2.231964</td>\n",
-       "      <td>1.971280</td>\n",
-       "      <td>0.462158</td>\n",
-       "      <td>00:01</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>2</td>\n",
-       "      <td>1.711358</td>\n",
-       "      <td>1.813547</td>\n",
-       "      <td>0.461182</td>\n",
-       "      <td>00:01</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>3</td>\n",
-       "      <td>1.448516</td>\n",
-       "      <td>1.828176</td>\n",
-       "      <td>0.483236</td>\n",
-       "      <td>00:01</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>4</td>\n",
-       "      <td>1.288630</td>\n",
-       "      <td>1.659564</td>\n",
-       "      <td>0.520671</td>\n",
-       "      <td>00:01</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>5</td>\n",
-       "      <td>1.161470</td>\n",
-       "      <td>1.714023</td>\n",
-       "      <td>0.554932</td>\n",
-       "      <td>00:01</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>6</td>\n",
-       "      <td>1.055568</td>\n",
-       "      <td>1.660916</td>\n",
-       "      <td>0.575033</td>\n",
-       "      <td>00:01</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>7</td>\n",
-       "      <td>0.960765</td>\n",
-       "      <td>1.719624</td>\n",
-       "      <td>0.591064</td>\n",
-       "      <td>00:01</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>8</td>\n",
-       "      <td>0.870153</td>\n",
-       "      <td>1.839560</td>\n",
-       "      <td>0.614665</td>\n",
-       "      <td>00:01</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>9</td>\n",
-       "      <td>0.808545</td>\n",
-       "      <td>1.770278</td>\n",
-       "      <td>0.624349</td>\n",
-       "      <td>00:01</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>10</td>\n",
-       "      <td>0.758084</td>\n",
-       "      <td>1.842931</td>\n",
-       "      <td>0.610758</td>\n",
-       "      <td>00:01</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>11</td>\n",
-       "      <td>0.719320</td>\n",
-       "      <td>1.799527</td>\n",
-       "      <td>0.646566</td>\n",
-       "      <td>00:01</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>12</td>\n",
-       "      <td>0.683439</td>\n",
-       "      <td>1.917928</td>\n",
-       "      <td>0.649821</td>\n",
-       "      <td>00:01</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>13</td>\n",
-       "      <td>0.660283</td>\n",
-       "      <td>1.874712</td>\n",
-       "      <td>0.628581</td>\n",
-       "      <td>00:01</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>14</td>\n",
-       "      <td>0.646154</td>\n",
-       "      <td>1.877519</td>\n",
-       "      <td>0.640055</td>\n",
-       "      <td>00:01</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>"
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "learn = Learner(dls, LMModel4(len(vocab), 64), loss_func=loss_func,\n",
-    "                metrics=accuracy, cbs=ModelReseter)\n",
-    "learn.fit_one_cycle(15, 3e-3)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We need to train for longer, since the task has changed a bit and is more complicated now. But we end up with a good result... At least, sometimes. If you run it a few times, you'll see that you can get quite different results on different runs. That's because effectively we have a very deep network here, which can result in very large or very small gradients. We'll see in the next chapter how to resolve this, by using the `LSTM` architecture.\n",
-    "\n",
-    "We can also see that `valid_loss` is getting worse, so it may help to add some additional regularization. That will be provided by the `AWD` variant of `LSTM`, which we'll also see in the next chapter.\n",
-    "\n",
-    "By combining these techniques, we'll see how to get around 85% accuracy on this dataset!"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Questionnaire"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "1. If the dataset for your project is so big and complicated that working with it takes a significant amount of time, what should you do?\n",
-    "1. Why do we concatenating the documents in our dataset before creating a language model?\n",
-    "1. To use a standard fully connected network to predict the fourth word given the previous three words, what two tweaks do we need to make?\n",
-    "1. How can we share a weight matrix across multiple layers in PyTorch?\n",
-    "1. Write a module which predicts the third word given the previous two words of a sentence, without peeking.\n",
-    "1. What is a recurrent neural network?\n",
-    "1. What is hidden state?\n",
-    "1. What is the equivalent of hidden state in ` LMModel1`?\n",
-    "1. To maintain the state in an RNN why is it important to pass the text to the model in order?\n",
-    "1. What is an unrolled representation of an RNN?\n",
-    "1. Why can maintaining the hidden state in an RNN lead to memory and performance problems? How do we fix this problem?\n",
-    "1. What is BPTT?\n",
-    "1. Write code to print out the first few batches of the validation set, including converting the token IDs back into English strings, as we showed for batches of IMDb data in the previous chapter.\n",
-    "1. What does the `ModelReseter` callback do? Why do we need it?\n",
-    "1. What are the downsides of predicting just one output word for each three input words?\n",
-    "1. Why do we need a custom loss function for `LMModel4`?\n",
-    "1. Why is the training of `LMModel4` unstable?"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Further research"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "1. In ` LMModel2` why can `forward` start with `h=0`? Why don't we need to say `h=torch.zeros(…)`?"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "jupytext": {
-   "split_at_heading": true
-  },
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.7.5"
-  },
-  "toc": {
-   "base_numbering": 1,
-   "nav_menu": {},
-   "number_sections": false,
-   "sideBar": true,
-   "skip_h1_title": true,
-   "title_cell": "Table of Contents",
-   "title_sidebar": "Contents",
-   "toc_cell": false,
-   "toc_position": {},
-   "toc_section_display": true,
-   "toc_window_display": false
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/12_better_rnn.ipynb b/12_better_rnn.ipynb
deleted file mode 100644
index 22b14ca..0000000
--- a/12_better_rnn.ipynb
+++ /dev/null
@@ -1,1154 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#hide\n",
-    "from utils import *"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "hide_input": false
-   },
-   "outputs": [],
-   "source": [
-    "#hide\n",
-    "from fastai2.text.all import *\n",
-    "path = untar_data(URLs.HUMAN_NUMBERS)\n",
-    "lines = L()\n",
-    "with open(path/'train.txt') as f: lines += L(*f.readlines())\n",
-    "with open(path/'valid.txt') as f: lines += L(*f.readlines())\n",
-    "text = ' . '.join([l.strip() for l in lines])\n",
-    "tokens = text.split(' ')\n",
-    "vocab = L(*tokens).unique()\n",
-    "word2idx = {w:i for i,w in enumerate(vocab)}\n",
-    "nums = L(word2idx[i] for i in tokens)\n",
-    "\n",
-    "def group_chunks(ds, bs):\n",
-    "    m = len(ds) // bs\n",
-    "    new_ds = L()\n",
-    "    for i in range(m): new_ds += L(ds[i + m*j] for j in range(bs))\n",
-    "    return new_ds"
-   ]
-  },
-  {
-   "cell_type": "raw",
-   "metadata": {},
-   "source": [
-    "[[chapter_better_rnn]]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Making our RNN state of the art"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We saw in the last chapter how to build a basic RNN from scratch. Now we will see how to make it better up until the AWD LSTM architecture we used in <<chapter_nlp>> on this text classification problem.\n",
-    "\n",
-    "We won't go other the whole data preparation process again. To make the comparison fair against our last example, we use the same batch size and sequence length:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "sl,bs = 16,64\n",
-    "seqs = L((tensor(nums[i:i+sl]), tensor(nums[i+1:i+sl+1]))\n",
-    "         for i in range(0,len(nums)-sl-1,sl))\n",
-    "cut = int(len(seqs) * 0.8)\n",
-    "dls = DataLoaders.from_dsets(group_chunks(seqs[:cut], bs),\n",
-    "                             group_chunks(seqs[cut:], bs),\n",
-    "                             bs=bs, drop_last=True, shuffle=False)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "The obvious way to get a better model is to go deeper: as we discussed in the last chapter, we only have one linear layer between the hidden state and the output activations in our basic RNN, so maybe we would get better results with more."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Multilayer RNNs"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### The model"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "In a multilayer RNN, we pass the activations from our recurrent neural network into a second recurrent neural network, like so:"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<img alt=\"2-layer RNN\" width=\"550\" caption=\"2-layer RNN\" id=\"stacked_rnn_rep\" src=\"images/att_00025.png\">"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "…or in an unrolled representation:"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<img alt=\"2-layer unrolled RNN\" width=\"500\" caption=\"2-layer unrolled RNN\" id=\"unrolled_stack_rep\" src=\"images/att_00026.png\">"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Let's save some time by using PyTorch's RNN class, which implements exactly what we have created above, but also gives us the option to stack multiple RNNs, as we have discussed:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class LMModel5(Module):\n",
-    "    def __init__(self, vocab_sz, n_hidden, n_layers):\n",
-    "        self.i_h = nn.Embedding(vocab_sz, n_hidden)\n",
-    "        self.rnn = nn.RNN(n_hidden, n_hidden, n_layers, batch_first=True)\n",
-    "        self.h_o = nn.Linear(n_hidden, vocab_sz)\n",
-    "        self.h = torch.zeros(n_layers, bs, n_hidden)\n",
-    "        \n",
-    "    def forward(self, x):\n",
-    "        res,h = self.rnn(self.i_h(x), self.h)\n",
-    "        self.h = h.detach()\n",
-    "        return self.h_o(res)\n",
-    "    \n",
-    "    def reset(self): self.h.zero_()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: left;\">\n",
-       "      <th>epoch</th>\n",
-       "      <th>train_loss</th>\n",
-       "      <th>valid_loss</th>\n",
-       "      <th>accuracy</th>\n",
-       "      <th>time</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <td>0</td>\n",
-       "      <td>3.055853</td>\n",
-       "      <td>2.591640</td>\n",
-       "      <td>0.437907</td>\n",
-       "      <td>00:01</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>1</td>\n",
-       "      <td>2.162359</td>\n",
-       "      <td>1.787310</td>\n",
-       "      <td>0.471598</td>\n",
-       "      <td>00:01</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>2</td>\n",
-       "      <td>1.710663</td>\n",
-       "      <td>1.941807</td>\n",
-       "      <td>0.321777</td>\n",
-       "      <td>00:01</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>3</td>\n",
-       "      <td>1.520783</td>\n",
-       "      <td>1.999726</td>\n",
-       "      <td>0.312012</td>\n",
-       "      <td>00:01</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>4</td>\n",
-       "      <td>1.330846</td>\n",
-       "      <td>2.012902</td>\n",
-       "      <td>0.413249</td>\n",
-       "      <td>00:01</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>5</td>\n",
-       "      <td>1.163297</td>\n",
-       "      <td>1.896192</td>\n",
-       "      <td>0.450684</td>\n",
-       "      <td>00:01</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>6</td>\n",
-       "      <td>1.033813</td>\n",
-       "      <td>2.005209</td>\n",
-       "      <td>0.434814</td>\n",
-       "      <td>00:01</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>7</td>\n",
-       "      <td>0.919090</td>\n",
-       "      <td>2.047083</td>\n",
-       "      <td>0.456706</td>\n",
-       "      <td>00:01</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>8</td>\n",
-       "      <td>0.822939</td>\n",
-       "      <td>2.068031</td>\n",
-       "      <td>0.468831</td>\n",
-       "      <td>00:01</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>9</td>\n",
-       "      <td>0.750180</td>\n",
-       "      <td>2.136064</td>\n",
-       "      <td>0.475098</td>\n",
-       "      <td>00:01</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>10</td>\n",
-       "      <td>0.695120</td>\n",
-       "      <td>2.139140</td>\n",
-       "      <td>0.485433</td>\n",
-       "      <td>00:01</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>11</td>\n",
-       "      <td>0.655752</td>\n",
-       "      <td>2.155081</td>\n",
-       "      <td>0.493652</td>\n",
-       "      <td>00:01</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>12</td>\n",
-       "      <td>0.629650</td>\n",
-       "      <td>2.162583</td>\n",
-       "      <td>0.498535</td>\n",
-       "      <td>00:01</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>13</td>\n",
-       "      <td>0.613583</td>\n",
-       "      <td>2.171649</td>\n",
-       "      <td>0.491048</td>\n",
-       "      <td>00:01</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>14</td>\n",
-       "      <td>0.604309</td>\n",
-       "      <td>2.180355</td>\n",
-       "      <td>0.487874</td>\n",
-       "      <td>00:01</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>"
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "learn = Learner(dls, LMModel5(len(vocab), 64, 2), loss_func=CrossEntropyLossFlat(), metrics=accuracy, cbs=ModelReseter)\n",
-    "learn.fit_one_cycle(15, 3e-3)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Now that's disappointing... we are doing more poorly than the single-layer RNN from the end of last chapter. The reason is that we have a deeper model, leading to exploding or disappearing activations."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Exploding or disappearing activations"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "In practice, creating accurate models from this kind of RNN is difficult. We will get better results if we call `detach` less often, and have more layers — this gives our RNN a longer time horizon to learn from, and richer features to create. But it also means we have a deeper model to train. The key challenge in the development of deep learning has been figuring out how to train these kinds of models.\n",
-    "\n",
-    "The reason this is challenging is because of what happens when you multiply by a matrix many times. Think about what happens when you multiply by a number many times. For example, if you multiply by two, starting at one, you get the sequence 1, 2, 4, 8,… after 32 steps you are already at 4,294,967,296. A similar issue happens if we multiply by 0.5: we get 0.5, 0.25, 0.125… and after 32 steps it's 0.00000000023. As you can see, a number even slightly higher or lower than one results in an explosion or disappearance of our number, after just a few repeated multiplications.\n",
-    "\n",
-    "Because matrix multiplication is just multiplying numbers and adding them up, exactly the same thing happens with repeated matrix multiplications. And a deep neural network is just repeated matrix multiplications--each extra layer is another matrix multiplication. This means that it is very easy for a deep neural network to end up with extremely large, or extremely small numbers.\n",
-    "\n",
-    "This is a problem, because the way computers store numbers (known as \"floating point\") means that they become less and less accurate the further away the numbers get from zero. This diagram, from the excellent article [What you never wanted to know about floating point but will be forced to find out](http://www.volkerschatz.com/science/float.html), shows how the precision of floating point numbers varies over the number line:"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<img alt=\"Precision of floating point numbers\" width=\"1000\" caption=\"Precision of floating point numbers\" id=\"float_prec\" src=\"images/fltscale.svg\">"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "This inaccuracy means that often the gradients calculated for updating the weights end up as zero or infinity for deep networks. This is commonly refered to as *vanishing gradients* or *exploding gradients*. That means that in SGD, the weights are updated either not at all, or jump to infinity. Either way, they won't improve with training.\n",
-    "\n",
-    "Researchers have developed a number of ways to tackle this problem, which we will be discussing later in the book. One way to tackle the problem is to change the definition of a layer in a way that makes it less likely to have exploding activations. We'll look at the details of how this is done in <<chapter_deep_conv>>, when we discuss *batch normalization*, and <<chapter_resnet>>, when we discuss *ResNets*, although these details don't generally matter in practice (unless you are a researcher that is creating new approaches to solving this problem). Another way to deal with this is by being careful about *initialization*, which is a topic we'll investigate in <<chapter_foundations>>.\n",
-    "\n",
-    "For RNNs, there are two types of layers frequently used to avoid exploding activations, and they are: *gated recurrent units* (GRU), and *Long Short-Term Memory* (LSTM). Both of these are available in PyTorch, and are drop-in replacements for the RNN layer. We will only cover LSTMs in this book, there are plenty of good tutorials online explaining GRUs, which are a minor variant on the LSTM design."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## LSTM"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "LSTM (for long short-term memory) is an architecture that was introduced back in 1997 by Jurgen Schmidhuber and Sepp Hochreiter. In this architecture, there are not one but two hidden states. In our base RNN, the hidden state is the output of the RNN at the previous time step. That hidden state is then responsible for doing two things at a time:\n",
-    "\n",
-    "- having the right information for the output layer to predict the correct next token\n",
-    "- retaining memory of everything that happened in the sentence\n",
-    "\n",
-    "Consider, for example, the sentences \"Henry has a dog and he likes his dog very much\" and \"Sophie has a dog and she likes her dog very much\". It's very clear that the RNN needs to remember the name at the beginning of the sentence to be able to predict *he/she* or *his/her*. \n",
-    "\n",
-    "In practice, RNNs are really bad at retaining memory of what happened much earlier in the sentence, which is the motivation to have another hidden state (called cell state) in the LSTM. The cell state will be responsible for keeping *long short-term memory*, while the hidden state will focus on the next token to predict. Let's have a closer look and how this is achieved and build one LSTM from scratch."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Building an LSTM from scratch"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "The schematic of an LSTM is given like so:\n",
-    "\n",
-    "<img src=\"images/LSTM.png\" id=\"lstm\" caption=\"Architecture of an LSTM\" alt=\"A graph showing the inner architecture of an LSTM\" width=\"700\">"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "In this picture, our input $x_{t}$ enters on the bottom with the previous hidden state ($h_{t-1}$) and cell state ($x_{t-1}$). The four orange boxes represent four layers with the activation being either sigmoid (for $\\sigma$) or tanh. tanh is just a sigmoid rescaled to the range -1 to 1. Its mathematical expression can be written like this:\n",
-    "\n",
-    "$$\\tanh(x) = \\frac{e^{x} + e^{-x}}{e^{x}-e^{-x}} = 2 \\sigma(2x) - 1$$\n",
-    "\n",
-    "where $\\sigma$ is the sigmoid function. The green boxes are elementwise operations. What goes out is the new hidden state ($h_{t}$) and new cell state ($c_{t}$) on the left, ready for our next input. The new hidden state is also use as output, which is why the arrow splits to go up.\n",
-    "\n",
-    "Let's go over the four neural nets (called *gates*) one by one and explain the diagram, but before this, notice how very little the cell state (on the top) is changed. It doesn't even go directly through a neural net! This is exactly why it will carry on a longer-term state.\n",
-    "\n",
-    "First, the arrows for input and old hidden state are joined together. In the RNN we wrote in the past chapter, we were adding them together. In the LSTM, we stack them in one big tensor. This means the dimension of our embeddings (which is the dimension of $x_{t}$) can be different than the dimension of our hidden state. If we call those `n_in` and `n_hid`, the arrow at the bottom is of size `n_in + n_hid`, thus all the neural nets (orange boxes) are linear layers with `n_in + n_hid` inputs and `n_hid` outputs.\n",
-    "\n",
-    "The first gate (looking from the left to right) is called the *forget gate*. Since it's a linear layer followed by a sigmoid, its output will have scalars between 0 and 1. We multiply this result by the cell gate, so for all the values close to 0, we will forget what was inside that cell state (and for the values close to 1 it doesn't do anything). This gives the ability to the LSTM to forget things about its longterm state. For instance, when crossing a period or an `xxbos` token, we would expect to it to (have learned to) reset its cell state.\n",
-    "\n",
-    "The second gate is called the *input gate*. It works with the third gate (which doesn't really have a name but is sometimes called the *cell gate*) to update the cell state. For instance we may see a new gender pronoun, so we must replace the information about gender that the forget gate removed by the new one. Like the forget gate, the input gate ends up on a product, so it jsut decides which element of the cell state to update (valeus close to 1) or not (values close to 0). The third gate will then fill those values with things between -1 and 1 (thanks to the tanh). The result is then added to the cell state.\n",
-    "\n",
-    "The last gate is the *output gate*. It will decides which information take in the cell state to generate the output. The cell state goes through a tanh before this and the output gate combined with the sigmoid decides which values to take inside it.\n",
-    "\n",
-    "In terms of code, we can write the same steps like this:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class LSTMCell(Module):\n",
-    "    def __init__(self, ni, nh):\n",
-    "        self.forget_gate = nn.Linear(ni + nh, nh)\n",
-    "        self.input_gate  = nn.Linear(ni + nh, nh)\n",
-    "        self.cell_gate   = nn.Linear(ni + nh, nh)\n",
-    "        self.output_gate = nn.Linear(ni + nh, nh)\n",
-    "\n",
-    "    def forward(self, input, state):\n",
-    "        h,c = state\n",
-    "        h = torch.stack([h, input], dim=1)\n",
-    "        forget = torch.sigmoid(self.forget_gate(h))\n",
-    "        c = c * forget\n",
-    "        inp = torch.sigmoid(self.input_gate(h))\n",
-    "        cell = torch.tanh(self.cell_gate(h))\n",
-    "        c = c + inp * cell\n",
-    "        out = torch.sigmoid(self.output_gate(h))\n",
-    "        h = outgate * torch.tanh(c)\n",
-    "        return h, (h,c)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "In practice, we can then refactor the code. Also, in terms of performance, it's better to do one big matrix multiplication than four smaller ones (that's because we only launch the special fast kernel on GPU once, and it gives the GPU more work to do in parallel). The stacking takes a bit of time (since we have to move one of the tensors around on the GPU to have it all in a contiguous array), so we use two separate layers for the input and the hidden state. The optimized and refactored code then looks like that:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class LSTMCell(Module):\n",
-    "    def __init__(self, ni, nh):\n",
-    "        self.ih = nn.Linear(ni,4*nh)\n",
-    "        self.hh = nn.Linear(nh,4*nh)\n",
-    "\n",
-    "    def forward(self, input, state):\n",
-    "        h,c = state\n",
-    "        #One big multiplication for all the gates is better than 4 smaller ones\n",
-    "        gates = (self.ih(input) + self.hh(h)).chunk(4, 1)\n",
-    "        ingate,forgetgate,outgate = map(torch.sigmoid, gates[:3])\n",
-    "        cellgate = gates[3].tanh()\n",
-    "\n",
-    "        c = (forgetgate*c) + (ingate*cellgate)\n",
-    "        h = outgate * c.tanh()\n",
-    "        return h, (h,c)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Here we use the PyTorch `chunk` method to split our tensor into 4 pieces, e.g.:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "tensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "t = torch.arange(0,10); t"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(tensor([0, 1, 2, 3, 4]), tensor([5, 6, 7, 8, 9]))"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "t.chunk(2)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Training a language model using LSTMs"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Here is the same network as before, using a two-layer LSTM. We can train it at a higher learning rate, for a shorter time, and get better accuracy:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class LMModel6(Module):\n",
-    "    def __init__(self, vocab_sz, n_hidden, n_layers):\n",
-    "        self.i_h = nn.Embedding(vocab_sz, n_hidden)\n",
-    "        self.rnn = nn.LSTM(n_hidden, n_hidden, n_layers, batch_first=True)\n",
-    "        self.h_o = nn.Linear(n_hidden, vocab_sz)\n",
-    "        self.h = [torch.zeros(2, bs, n_hidden) for _ in range(n_layers)]\n",
-    "        \n",
-    "    def forward(self, x):\n",
-    "        res,h = self.rnn(self.i_h(x), self.h)\n",
-    "        self.h = [h_.detach() for h_ in h]\n",
-    "        return self.h_o(res)\n",
-    "    \n",
-    "    def reset(self): \n",
-    "        for h in self.h: h.zero_()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: left;\">\n",
-       "      <th>epoch</th>\n",
-       "      <th>train_loss</th>\n",
-       "      <th>valid_loss</th>\n",
-       "      <th>accuracy</th>\n",
-       "      <th>time</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <td>0</td>\n",
-       "      <td>3.000821</td>\n",
-       "      <td>2.663942</td>\n",
-       "      <td>0.438314</td>\n",
-       "      <td>00:02</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>1</td>\n",
-       "      <td>2.139642</td>\n",
-       "      <td>2.184780</td>\n",
-       "      <td>0.240479</td>\n",
-       "      <td>00:02</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>2</td>\n",
-       "      <td>1.607275</td>\n",
-       "      <td>1.812682</td>\n",
-       "      <td>0.439779</td>\n",
-       "      <td>00:02</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>3</td>\n",
-       "      <td>1.347711</td>\n",
-       "      <td>1.830982</td>\n",
-       "      <td>0.497477</td>\n",
-       "      <td>00:02</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>4</td>\n",
-       "      <td>1.123113</td>\n",
-       "      <td>1.937766</td>\n",
-       "      <td>0.594401</td>\n",
-       "      <td>00:02</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>5</td>\n",
-       "      <td>0.852042</td>\n",
-       "      <td>2.012127</td>\n",
-       "      <td>0.631592</td>\n",
-       "      <td>00:02</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>6</td>\n",
-       "      <td>0.565494</td>\n",
-       "      <td>1.312742</td>\n",
-       "      <td>0.725749</td>\n",
-       "      <td>00:02</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>7</td>\n",
-       "      <td>0.347445</td>\n",
-       "      <td>1.297934</td>\n",
-       "      <td>0.711263</td>\n",
-       "      <td>00:02</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>8</td>\n",
-       "      <td>0.208191</td>\n",
-       "      <td>1.441269</td>\n",
-       "      <td>0.731201</td>\n",
-       "      <td>00:02</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>9</td>\n",
-       "      <td>0.126335</td>\n",
-       "      <td>1.569952</td>\n",
-       "      <td>0.737305</td>\n",
-       "      <td>00:02</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>10</td>\n",
-       "      <td>0.079761</td>\n",
-       "      <td>1.427187</td>\n",
-       "      <td>0.754150</td>\n",
-       "      <td>00:02</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>11</td>\n",
-       "      <td>0.052990</td>\n",
-       "      <td>1.494990</td>\n",
-       "      <td>0.745117</td>\n",
-       "      <td>00:02</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>12</td>\n",
-       "      <td>0.039008</td>\n",
-       "      <td>1.393731</td>\n",
-       "      <td>0.757894</td>\n",
-       "      <td>00:02</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>13</td>\n",
-       "      <td>0.031502</td>\n",
-       "      <td>1.373210</td>\n",
-       "      <td>0.758464</td>\n",
-       "      <td>00:02</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>14</td>\n",
-       "      <td>0.028068</td>\n",
-       "      <td>1.368083</td>\n",
-       "      <td>0.758464</td>\n",
-       "      <td>00:02</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>"
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "learn = Learner(dls, LMModel6(len(vocab), 64, 2), loss_func=CrossEntropyLossFlat(), metrics=accuracy, cbs=ModelReseter)\n",
-    "learn.fit_one_cycle(15, 1e-2)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Now that's better than a multilayer RNN! We can still see there is a bit of overfitting, which is a sign that a bit of regularization might help."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Regularizing an LSTM"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Recurrent neural networks, in general, are hard to train. Using LSTMs (or GRUs) cell make training easier than vanilla RNNs, but there are still very prone to overfitting. Data augmentation, while it exists for text data, is less often used because in most cases, it requires another model to generate random augmentation (by translating in another language and back to the language used for instance). Overall, data augmentation for text data is currently not a well explored space.\n",
-    "\n",
-    "However, there are other regularization techniques we can use instead, which were thoroughly studied for use with LSTMs in the paper [Regularizing and Optimizing LSTM Language Models](https://arxiv.org/abs/1708.02182). This paper showed how effective use of *dropout*, *activation regularization*, and *temporal activation regularization* could allow an LSTM to beat state of the art results that previously required much more complicated models. They called an LSTM using these techniques an *AWD LSTM*. We'll look at each of these techniques in turn."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Dropout"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Dropout is a regularization technique that was introduce by Geoffrey Hinton et al. in [Improving neural networks by preventing co-adaptation of feature detectors](https://arxiv.org/abs/1207.0580). The basic idea is to randomly change some activations to zero at training time. This makes sure all neurons actively work toward the output as seen in this figure from the original paper:\n",
-    "\n",
-    "<img src=\"images/Dropout1.png\" alt=\"A figure from the article showing how neurons go off with dropout\" width=\"800\">\n",
-    "\n",
-    "Hinton used a nice metaphor when he explained, in an interview, the inspiration for dropout:\n",
-    "\n",
-    "> : \"I went to my bank. The tellers kept changing and I asked one of them why. He said he didn’t know but they got moved around a lot. I figured it must be because it would require cooperation between employees to successfully defraud the bank. This made me realize that randomly removing a different subset of neurons on each example would prevent conspiracies and thus reduce overfitting\"\n",
-    "\n",
-    "In the same interview, he also explained that neuroscience provided additional inspiration:\n",
-    "\n",
-    "> : \"We don't really know why neurons spike. One theory is that they want to be noisy so as to regularize, because we have many more parameters than we have data points. The idea of dropout is that if you have noisy activations, you can afford to use a much bigger model.\""
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We can see there that if we just zero those activations without doing anything else, our model will have problems to train: if we go from the sum of 5 activations (that are all positive numbers since we apply a ReLU) to just 2, this won't have the same scale. Therefore if we dropout with a probability `p`, we rescale all activation by dividing them by `1-p` (on average `p` will be zeroed, so it leaves `1-p`), as shown in this diagram from the original paper:\n",
-    "\n",
-    "<img src=\"images/Dropout.png\" alt=\"A figure from the article introducing dropout showing how a neuron is on/off\" width=\"600\">\n",
-    "\n",
-    "This is a full implementation of the dropout layer in PyTorch (although PyTorch's native layer is actually written in C, not Python):"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class Dropout(Module):\n",
-    "    def __init__(self, p): self.p = p\n",
-    "    def forward(self, x):\n",
-    "        if not self.training: return x\n",
-    "        mask = x.new(*x.shape).bernoulli_(1-p)\n",
-    "        return x * mask.div_(1-p)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "The `bernoulli_` method is creating a tensor with random zeros (with probability p) and ones (with probability 1-p), which is then multiplied with our input before dividing by `1-p`. Note the use of the `training` attribute, which is available in any PyTorch `nn.Module`, and tells us if we are doing training or inference.\n",
-    "\n",
-    "> note: In previous chapters of the book we'd be adding a code example for `bernoulli_` here, so you can see exactly how it works. But now that you know enough to do this yourself, we're going to be doing fewer and fewer examples for you, and instead expecting you to do your own experiments to see how things work. In this case, you'll see in the end-of-chapter questionnaire that we're asking you to experiment with `bernoulli_`--but don't wait for us to ask you to experiment to develop your understanding of the code we're studying, go ahead and do it anyway!\n",
-    "\n",
-    "Using dropout before passing the output of our LSTM to the final layer will help reduce overfitting. Dropout is also used in many other models, including the default CNN head used in `fastai.vision`, and is also available in `fastai.tabular` by passing the `ps` parameter (where each \"p\" is passed to each added `Dropout` layer), as we'll see in <<chapter_arch_details>>."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Dropout has a different behavior in training and validation mode, which we achieved using the `training` attribute in `Dropout` above. Calling the `train()` method on a `Module` sets `training` to `True` (both for the module you call the method on, and for every module it recursively contains), and `eval()` sets it to `False`. This is done automatically when calling the methods of `Learner`, but if you are not using that class, remember to switch from one to the other as needed."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### AR and TAR regularization"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "AR (for *activation regularization*) and TAR (for *temporal activation regularization*) are two regularization methods very similar to weight decay. When applying weight decay, we add a small penalty to the loss that aims at making the weights as small as possible. For the activation regularization, it's the final activations produced by the LSTM that we will try to make as small as possible, instead of the weights.\n",
-    "\n",
-    "To regularize the final activations, we have to store those somewhere, then add the means of the squares of them to the loss (along with a multiplier `alpha`, which is just like `wd` for weight decay):\n",
-    "\n",
-    "``` python\n",
-    "loss += alpha * activations.pow(2).mean()\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Temporal activation regularization is linked to the fact we are predicting tokens in a sentence. That means it's likely that the outputs of our LSTMs should somewhat make sense when we read them in order. TAR is there to encourage that behavior by adding a penalty to the loss to make the difference between two consecutive activations as small as possible: our activations tensor has a shape `bs x sl x n_hid`, and we read consecutive activation on the sequence length axis (so the dimension in the middle). With this, TAR can be expressed as:\n",
-    "\n",
-    "``` python\n",
-    "loss += beta * (activations[:,1:] - activations[:,:-1]).pow(2).mean()\n",
-    "```\n",
-    "\n",
-    "`alpha` and `beta` are then two hyper-parameters to tune. To make this work, we need our model with dropout to return three things: the proper output, the activations of the LSTM pre-dropout and the activations of the LSTM post-dropout. AR is often applied on the dropped out activations (to not penalize the activations we turned in 0s afterward) while TAR is applied on the non-dropped out activations (because those 0s create big differences between two consecutive timesteps). There is then a callback called `RNNRegularizer` that will apply this regularization for us."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Training a weight-tied regularized LSTM"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We can combine dropout (applied before we go in our output layer) with the AR and TAR regularization to train our previous LSTM. We just need to return three things instead of one: the normal output of our LSTM, the dropped-out activations and the activations from our LSTMs. Those last two will be picked up by the callback `RNNRegularization` for the contributions it has to make to the loss.\n",
-    "\n",
-    "Another useful trick we can add from the AWD LSTM paper is *weight tying*. In a language model, the input embeddings represent a mapping from English words to activations, and the output hidden layer represents a mapping from activations to English words. We might expect, intuitively, that these mappings could be the same. We can represent this in PyTorch by assigning the same weight matrix to each of these layers:\n",
-    "\n",
-    "    self.h_o.weight = self.i_h.weight\n",
-    "\n",
-    "In `LMMModel7`, we include these final tweaks:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class LMModel7(Module):\n",
-    "    def __init__(self, vocab_sz, n_hidden, n_layers, p):\n",
-    "        self.i_h = nn.Embedding(vocab_sz, n_hidden)\n",
-    "        self.rnn = nn.LSTM(n_hidden, n_hidden, n_layers, batch_first=True)\n",
-    "        self.drop = nn.Dropout(p)\n",
-    "        self.h_o = nn.Linear(n_hidden, vocab_sz)\n",
-    "        self.h_o.weight = self.i_h.weight\n",
-    "        self.h = [torch.zeros(2, bs, n_hidden) for _ in range(n_layers)]\n",
-    "        \n",
-    "    def forward(self, x):\n",
-    "        raw,h = self.rnn(self.i_h(x), self.h)\n",
-    "        out = self.drop(raw)\n",
-    "        self.h = [h_.detach() for h_ in h]\n",
-    "        return self.h_o(out),raw,out\n",
-    "    \n",
-    "    def reset(self): \n",
-    "        for h in self.h: h.zero_()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We can create a regularized `Learner` using the `RNNRegularizer` callback:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "learn = Learner(dls, LMModel7(len(vocab), 64, 2, 0.5),\n",
-    "                loss_func=CrossEntropyLossFlat(), metrics=accuracy,\n",
-    "                cbs=[ModelReseter, RNNRegularizer(alpha=2, beta=1)])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "A `TextLearner` automatically adds those two callbacks for us (with default for `alpha` and `beta` as above) so we can simplify the line above to:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "learn = TextLearner(dls, LMModel7(len(vocab), 64, 2, 0.4),\n",
-    "                    loss_func=CrossEntropyLossFlat(), metrics=accuracy)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We can the train the model, and add additional regularization by increasing the weight decay to `0.1`:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: left;\">\n",
-       "      <th>epoch</th>\n",
-       "      <th>train_loss</th>\n",
-       "      <th>valid_loss</th>\n",
-       "      <th>accuracy</th>\n",
-       "      <th>time</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <td>0</td>\n",
-       "      <td>2.693885</td>\n",
-       "      <td>2.013484</td>\n",
-       "      <td>0.466634</td>\n",
-       "      <td>00:02</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>1</td>\n",
-       "      <td>1.685549</td>\n",
-       "      <td>1.187310</td>\n",
-       "      <td>0.629313</td>\n",
-       "      <td>00:02</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>2</td>\n",
-       "      <td>0.973307</td>\n",
-       "      <td>0.791398</td>\n",
-       "      <td>0.745605</td>\n",
-       "      <td>00:02</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>3</td>\n",
-       "      <td>0.555823</td>\n",
-       "      <td>0.640412</td>\n",
-       "      <td>0.794108</td>\n",
-       "      <td>00:02</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>4</td>\n",
-       "      <td>0.351802</td>\n",
-       "      <td>0.557247</td>\n",
-       "      <td>0.836100</td>\n",
-       "      <td>00:02</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>5</td>\n",
-       "      <td>0.244986</td>\n",
-       "      <td>0.594977</td>\n",
-       "      <td>0.807292</td>\n",
-       "      <td>00:02</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>6</td>\n",
-       "      <td>0.192231</td>\n",
-       "      <td>0.511690</td>\n",
-       "      <td>0.846761</td>\n",
-       "      <td>00:02</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>7</td>\n",
-       "      <td>0.162456</td>\n",
-       "      <td>0.520370</td>\n",
-       "      <td>0.858073</td>\n",
-       "      <td>00:02</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>8</td>\n",
-       "      <td>0.142664</td>\n",
-       "      <td>0.525918</td>\n",
-       "      <td>0.842285</td>\n",
-       "      <td>00:02</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>9</td>\n",
-       "      <td>0.128493</td>\n",
-       "      <td>0.495029</td>\n",
-       "      <td>0.858073</td>\n",
-       "      <td>00:02</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>10</td>\n",
-       "      <td>0.117589</td>\n",
-       "      <td>0.464236</td>\n",
-       "      <td>0.867188</td>\n",
-       "      <td>00:02</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>11</td>\n",
-       "      <td>0.109808</td>\n",
-       "      <td>0.466550</td>\n",
-       "      <td>0.869303</td>\n",
-       "      <td>00:02</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>12</td>\n",
-       "      <td>0.104216</td>\n",
-       "      <td>0.455151</td>\n",
-       "      <td>0.871826</td>\n",
-       "      <td>00:02</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>13</td>\n",
-       "      <td>0.100271</td>\n",
-       "      <td>0.452659</td>\n",
-       "      <td>0.873617</td>\n",
-       "      <td>00:02</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>14</td>\n",
-       "      <td>0.098121</td>\n",
-       "      <td>0.458372</td>\n",
-       "      <td>0.869385</td>\n",
-       "      <td>00:02</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>"
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "learn.fit_one_cycle(15, 1e-2, wd=0.1)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Now this is far better than our previous model!"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Conclusion"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "You have now seen everything that is inside the AWD-LSTM architecture we used in text classification in <<chapter_nlp>>. It uses dropouts in a lot more places:\n",
-    "\n",
-    "- embedding dropout (just after the embedding layer)\n",
-    "- input dropout (after the embedding layer)\n",
-    "- weight dropout (applied to the weights of the LSTM at each training step)\n",
-    "- hidden dropout (applied to the hidden state between two layers)\n",
-    "\n",
-    "which makes it even more regularized. Since fine-tuning those five dropout values (adding the dropout before the output layer) is complicated, so we have determined good defaults, and allow the magnitude of dropout to be tuned overall with the `drop_mult` parameter you saw (which is multiplied by each dropout).\n",
-    "\n",
-    "Another architecture that is very powerful, especially in \"sequence to sequence\" problems (that is, problems where the dependent variable is itself a variable length sequence, such as language translation), is the Transformers architecture. You can find it in an online bonus chapter on the book website."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Questionnaire"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "1. In the unrolled representation, we can see that a recurrent neural network actually has many layers. So why do we need to stack RNNs to get better results?\n",
-    "1. Draw a representation of a stacked (multilayer) RNN.\n",
-    "1. Why should we get better results in an RNN if we call `detach` less often? Why might this not happen in practice with a simple RNN?\n",
-    "1. Why can a deep network result in very large or very small activations? Why does this matter?\n",
-    "1. In a computer's floating point representation of numbers, which numbers are the most precise?\n",
-    "1. Why do vanishing gradients prevent training?\n",
-    "1. Why does it help to have two hidden states in the LSTM architecture? What is the purpose of each one?\n",
-    "1. What are these two states called in an LSTM?\n",
-    "1. What is tanh, and how is it related to sigmoid?\n",
-    "1. What is the purpose of this code in `LSTMCell`?: `h = torch.stack([h, input], dim=1)`\n",
-    "1. What does `chunk` to in PyTorch?\n",
-    "1. Study the refactored version of `LSTMCell` carefully to ensure you understand how and why it does the same thing as the non-refactored version.\n",
-    "1. Why can we use a higher learning rate for `LMModel6`?\n",
-    "1. What are the three regularisation techniques used in an AWD-LSTM model?\n",
-    "1. What is dropout?\n",
-    "1. Why do we scale the weights with dropout? Is this applied during training, inference, or both?\n",
-    "1. What is the purpose of this line from `Dropout`?: `if not self.training: return x`\n",
-    "1. Experiment with `bernoulli_` to understand how it works.\n",
-    "1. How do you set your model in training mode in PyTorch? In evaluation mode?\n",
-    "1. Write the equation for activation regularization (in maths or code, as you prefer). How is it different to weight decay?\n",
-    "1. Write the equation for temporal activation regularization (in maths or code, as you prefer). Why wouldn't we use this for computer vision problems?\n",
-    "1. What is \"weight tying\" in a language model?"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Further research"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "1. Write the code for an LSTM from scratch (but you may refer to <<lstm>>).\n",
-    "1. Search on the Internet for the GRU architecture and implement it from scratch, and try training a model. See if you can get the similar results as we saw in this chapter. Compare it to the results of PyTorch's built in GRU module.\n",
-    "1. Have a look at the source code for AWD-LSTM in fastai, and try to map each of the lines of code to the concepts shown in this chapter."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "jupytext": {
-   "split_at_heading": true
-  },
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.7.5"
-  },
-  "toc": {
-   "base_numbering": 1,
-   "nav_menu": {},
-   "number_sections": false,
-   "sideBar": true,
-   "skip_h1_title": true,
-   "title_cell": "Table of Contents",
-   "title_sidebar": "Contents",
-   "toc_cell": false,
-   "toc_position": {},
-   "toc_section_display": true,
-   "toc_window_display": false
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/12_nlp_dive.ipynb b/12_nlp_dive.ipynb
new file mode 100644
index 0000000..2fcb33e
--- /dev/null
+++ b/12_nlp_dive.ipynb
@@ -0,0 +1,2350 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#hide\n",
+    "from utils import *"
+   ]
+  },
+  {
+   "cell_type": "raw",
+   "metadata": {},
+   "source": [
+    "[[chapter_nlp_dive]]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# A language model from scratch"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We're now ready to go deep... deep into deep learning! You already learned how to train a basic neural network, but how do you go from there to creating state of the art models? In this part of the book we're going to uncover all of the mysteries, starting with language models.\n",
+    "\n",
+    "We saw in <<chapter_nlp>> how to finetune a pretrained language model to build a text classifier, in this chapter, we will explain to you what exactly is inside that model, and what an RNN is. First, let's gather some data that will allow us to quickly prototype our various models. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## The data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Whenever we start working on a new problem, we always first try to think of the simplest dataset we can which would allow us to try out methods quickly and easily, and interpret the results. When we started working on language modelling a few years ago, we didn't find any datasets that would allow for quick prototyping, so we made one. We call it *human numbers*, and it simply contains the first 10,000 words written out in English."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "> j: One of the most common practical mistakes I see even amongst highly experienced practitioners is failing to use appropriate datasets at appropriate times during the analysis process. In particular, most people tend to start with datasets which are too big and too complicated."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can download, extract, and take a look at our dataset in the usual way:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from fastai2.text.all import *\n",
+    "path = untar_data(URLs.HUMAN_NUMBERS)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#hide\n",
+    "Path.BASE_PATH = path"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(#2) [Path('train.txt'),Path('valid.txt')]"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "path.ls()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's open those two files and see what's inside. At first we'll join all of those texts together and ignore the split train/valid given by the dataset, we will come back to it later on:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(#9998) ['one \\n','two \\n','three \\n','four \\n','five \\n','six \\n','seven \\n','eight \\n','nine \\n','ten \\n'...]"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "lines = L()\n",
+    "with open(path/'train.txt') as f: lines += L(*f.readlines())\n",
+    "with open(path/'valid.txt') as f: lines += L(*f.readlines())\n",
+    "lines"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We take all those lines and concatenate them in one big stream. To mark when we go from one number to the next, we use a '.' as separation:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'one . two . three . four . five . six . seven . eight . nine . ten . eleven . twelve . thirteen . fo'"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "text = ' . '.join([l.strip() for l in lines])\n",
+    "text[:100]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's use word tokenization for this dataset, by splitting on spaces:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['one', '.', 'two', '.', 'three', '.', 'four', '.', 'five', '.']"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "tokens = text.split(' ')\n",
+    "tokens[:10]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To numericalize, we have to create a list of all the unique tokens (our *vocab*):"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(#30) ['one','.','two','three','four','five','six','seven','eight','nine'...]"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "vocab = L(*tokens).unique()\n",
+    "vocab"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Then we can convert our tokens into numbers by looking up the index of each in the vocab:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(#63095) [0,1,2,1,3,1,4,1,5,1...]"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "word2idx = {w:i for i,w in enumerate(vocab)}\n",
+    "nums = L(word2idx[i] for i in tokens)\n",
+    "nums"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now that we have some small dataset on which language modelling should be an easy task, we can build our first model."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Our first language model from scratch"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "One simple way to turn this into a neural network would be to specify that we are going to predict each word based on the previous three words. Therefore, we could create a list of every sequence of three words as independent variables, and the next word after each sequence as the dependent variable. \n",
+    "\n",
+    "We can do that with plain Python. Let us do it first with tokens just to confirm what it looks like:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(#21031) [(['one', '.', 'two'], '.'),(['.', 'three', '.'], 'four'),(['four', '.', 'five'], '.'),(['.', 'six', '.'], 'seven'),(['seven', '.', 'eight'], '.'),(['.', 'nine', '.'], 'ten'),(['ten', '.', 'eleven'], '.'),(['.', 'twelve', '.'], 'thirteen'),(['thirteen', '.', 'fourteen'], '.'),(['.', 'fifteen', '.'], 'sixteen')...]"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "L((tokens[i:i+3], tokens[i+3]) for i in range(0,len(tokens)-4,3))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now we will do it with tensors of the numericalized values, which is what the model will actually use:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(#21031) [(tensor([0, 1, 2]), 1),(tensor([1, 3, 1]), 4),(tensor([4, 1, 5]), 1),(tensor([1, 6, 1]), 7),(tensor([7, 1, 8]), 1),(tensor([1, 9, 1]), 10),(tensor([10,  1, 11]), 1),(tensor([ 1, 12,  1]), 13),(tensor([13,  1, 14]), 1),(tensor([ 1, 15,  1]), 16)...]"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "seqs = L((tensor(nums[i:i+3]), nums[i+3]) for i in range(0,len(nums)-4,3))\n",
+    "seqs"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Then we can batch those easily using the `DataLoader` class. For now we will split randomly the sequences."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "bs = 64\n",
+    "cut = int(len(seqs) * 0.8)\n",
+    "dls = DataLoaders.from_dsets(seqs[:cut], seqs[cut:], bs=64, shuffle=False)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can now create a neural network architecture that takes three words as input, and returns a prediction of the probability of each possible next word in the vocab. We will use three standard linear layers, but with two tweaks.\n",
+    "\n",
+    "The first tweak is that the first linear layer will use only the first word's embedding as activations, the second layer will use the second word's embedding plus the first layer's output activations, and the third layer will use the third word's embedding plus the second layer's output activations. The key effect of this is that every word is interpreted in the information context of any words preceding it. \n",
+    "\n",
+    "The second tweak is that each of these three layers will use the same weight matrix. The way that one word impacts the activations from previous words should not change depending on the position of a word. In other words, activation values will change as data moves through the layers, but the layer weights themselves will not change from layer to layer. So a layer does not learn one sequence position; it must learn to handle all positions.\n",
+    "\n",
+    "Since layer weights do not change, you might think of the sequential layers as the \"same layer\" repeated. In fact  PyTorch makes this concrete; we can just create one layer, and use it multiple times."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Our language model in PyTorch"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can now create the language model module that we described earlier:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class LMModel1(Module):\n",
+    "    def __init__(self, vocab_sz, n_hidden):\n",
+    "        self.i_h = nn.Embedding(vocab_sz, n_hidden)  \n",
+    "        self.h_h = nn.Linear(n_hidden, n_hidden)     \n",
+    "        self.h_o = nn.Linear(n_hidden,vocab_sz)\n",
+    "        \n",
+    "    def forward(self, x):\n",
+    "        h = F.relu(self.h_h(self.i_h(x[:,0])))\n",
+    "        h = h + self.i_h(x[:,1])\n",
+    "        h = F.relu(self.h_h(h))\n",
+    "        h = h + self.i_h(x[:,2])\n",
+    "        h = F.relu(self.h_h(h))\n",
+    "        return self.h_o(h)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As you see, we have created three layers:\n",
+    "\n",
+    "- The embedding layer (`i_h` for *input* to *hidden*)\n",
+    "- The linear layer to create the activations for the next word (`h_h` for *hidden* to *hidden*)\n",
+    "- A final linear layer to predict the fourth word (`h_o` for *hidden* to *output*)\n",
+    "\n",
+    "This might be easier to represent in pictorial form. Let's define a simple pictorial representation of basic neural networks. <<img_simple_nn>> shows how we're going to represent a neural net with one hidden layer."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<img alt=\"Pictorial representation of simple neural network\" width=\"400\" src=\"images/att_00020.png\" caption=\"Pictorial representation of simple neural network\" id=\"img_simple_nn\">"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Each shape represents activations: rectangle for input, circle for hidden (inner) layer activations, and triangle for output activations. We will use those shapes (summarized in <<img_shapes>>) in all the diagrams of this chapter."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<img alt=\"Shapes used in our pictorial representations\" width=\"200\" src=\"images/att_00021.png\" id=\"img_shapes\" caption=\"Shapes used in our pictorial representations\">"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "An arrow represents the actual layer computation—i.e. the linear layer followed by the activation layers. Using this notation, <<lm_rep>> shows what our simple language model looks like."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<img alt=\"Representation of our basic language model\" width=\"500\" caption=\"Representation of our basic language model\" id=\"lm_rep\" src=\"images/att_00022.png\">"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To simplify things, we've removed the details of the layer computation from each arrow. We've also color-coded the arrows, such that all arrows with the same color have the same weight matrix. For instance, all the input layers use the same embedding matrix, so they all have the same color (green).\n",
+    "\n",
+    "Let's try training this model and see how it goes:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: left;\">\n",
+       "      <th>epoch</th>\n",
+       "      <th>train_loss</th>\n",
+       "      <th>valid_loss</th>\n",
+       "      <th>accuracy</th>\n",
+       "      <th>time</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <td>0</td>\n",
+       "      <td>1.824297</td>\n",
+       "      <td>1.970941</td>\n",
+       "      <td>0.467554</td>\n",
+       "      <td>00:02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>1</td>\n",
+       "      <td>1.386973</td>\n",
+       "      <td>1.823242</td>\n",
+       "      <td>0.467554</td>\n",
+       "      <td>00:02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>2</td>\n",
+       "      <td>1.417556</td>\n",
+       "      <td>1.654497</td>\n",
+       "      <td>0.494414</td>\n",
+       "      <td>00:02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>3</td>\n",
+       "      <td>1.376440</td>\n",
+       "      <td>1.650849</td>\n",
+       "      <td>0.494414</td>\n",
+       "      <td>00:02</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "learn = Learner(dls, LMModel1(len(vocab), 64), loss_func=F.cross_entropy, metrics=accuracy)\n",
+    "learn.fit_one_cycle(4, 1e-3)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To see if this is any good, let's check what would a very simple model give us. In this case we could always predict the most common token, so let's find out which token is the most often the target in our validation set:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(tensor(29), 'thousand', 0.15165200855716662)"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "n,counts = 0,torch.zeros(len(vocab))\n",
+    "for x,y in dls.valid:\n",
+    "    n += y.shape[0]\n",
+    "    for i in range_of(vocab): counts[i] += (y==i).long().sum()\n",
+    "idx = torch.argmax(counts)\n",
+    "idx, vocab[idx.item()], counts[idx].item()/n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The most common token has the index 29, which corresponds to the token 'thousand'. Always predicting this token would give us an accuracy of roughly 15\\%, so we are faring way better!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "> A: My first guess was that the separator would be the most common token, since there is one for every number. But looking at `tokens` reminded me that large numbers are written with many words, so on the way to 10,000 you write \"thousand\" a lot: five thousand, five thousand and one, five thousand and two, etc.. Oops! Looking at your data is great for noticing subtle features and also embarrassingly obvious ones."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This is a nice first baseline. Let's see how we can refactor this with a loop."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Our first recurrent neural network"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Looking at the code for our module, we could simplify it by replacing the duplicated code that calls the layers with a for loop. As well as making our code simpler, this will also have the benefit that we could apply our module equally well to token sequences of different lengths; we would not be restricted to token lists of length three."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class LMModel2(Module):\n",
+    "    def __init__(self, vocab_sz, n_hidden):\n",
+    "        self.i_h = nn.Embedding(vocab_sz, n_hidden)  \n",
+    "        self.h_h = nn.Linear(n_hidden, n_hidden)     \n",
+    "        self.h_o = nn.Linear(n_hidden,vocab_sz)\n",
+    "        \n",
+    "    def forward(self, x):\n",
+    "        h = 0\n",
+    "        for i in range(3):\n",
+    "            h = h + self.i_h(x[:,i])\n",
+    "            h = F.relu(self.h_h(h))\n",
+    "        return self.h_o(h)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's check that we get the same results using this refactoring:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: left;\">\n",
+       "      <th>epoch</th>\n",
+       "      <th>train_loss</th>\n",
+       "      <th>valid_loss</th>\n",
+       "      <th>accuracy</th>\n",
+       "      <th>time</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <td>0</td>\n",
+       "      <td>1.816274</td>\n",
+       "      <td>1.964143</td>\n",
+       "      <td>0.460185</td>\n",
+       "      <td>00:02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>1</td>\n",
+       "      <td>1.423805</td>\n",
+       "      <td>1.739964</td>\n",
+       "      <td>0.473259</td>\n",
+       "      <td>00:02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>2</td>\n",
+       "      <td>1.430327</td>\n",
+       "      <td>1.685172</td>\n",
+       "      <td>0.485382</td>\n",
+       "      <td>00:02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>3</td>\n",
+       "      <td>1.388390</td>\n",
+       "      <td>1.657033</td>\n",
+       "      <td>0.470406</td>\n",
+       "      <td>00:02</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "learn = Learner(dls, LMModel2(len(vocab), 64), loss_func=F.cross_entropy, metrics=accuracy)\n",
+    "learn.fit_one_cycle(4, 1e-3)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can also refactor our pictorial representation in exactly the same way, see <<basic_rnn>> (we're also removing the details of activation sizes here, and using the same arrow colors as in <<lm_rep>>)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<img alt=\"Basic recurrent neural network\" width=\"400\" caption=\"Basic recurrent neural network\" id=\"basic_rnn\" src=\"images/att_00070.png\">"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You will see that there is a set of activations which are being updated each time through the loop, and are stored in the variable `h` — this is called the *hidden state*."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "> Jargon: hidden state: the activations that are updated at each step of a recurrent neural network"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "A neural network which is defined using a loop like this is called a *recurrent neural network*, also known as an RNN. It is important to realise that an RNN is not a complicated new architecture, but is simply a refactoring of a multilayer neural network using a for loop.\n",
+    "\n",
+    "> A: My true opinion: if they were called \"looping neural networks\", or LNNs, they would seem 50% less daunting!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now that we know what an RNN is, let's try to make it a little bit beter."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Improving the RNN"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Looking at the code for our RNN, one thing that seems problematic is that we are initialising our hidden state to zero for every new input sequence. Why is that a problem? We made our sample sequences short so they would fit easily into batches. But if we order those samples correctly, those sample sequences will be read in order by the model, exposing the model to long stretches of the original sequence. \n",
+    "\n",
+    "Another thing we can look at is havin more signal: why only predict the fourth word when we could use the intermediate predictions to also predict the second and third words? \n",
+    "\n",
+    "We'll see how we can implement those changes, starting with adding some state."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Maintaining the state of an RNN"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Because we initialize the model's hidden state to zero for each new sample, we are throwing away all the information we have about the sentences we have seen so far, which means that our model doesn't actually know where we are up to in the overall counting sequence. This is easily fixed; we can simply move the initialisation of the hidden state to `__init__`.\n",
+    "\n",
+    "But this fix will create its own subtle, but important, problem. It effectively makes our neural network as deep as the entire number of tokens in our document. For instance, if there were 10,000 tokens in our dataset, we would be creating a 10,000 layer neural network.\n",
+    "\n",
+    "To see this, consider the original pictorial representation of our recurrent neural network in <<lm_rep>>, before refactoring it with a for loop. You can see each layer corresponds with one token input. When we talk about the representation of a recurrent neural network before refactoring with the for loop, we call this the *unrolled representation*. It is often helpful to consider the unrolled representation when trying to understand an RNN.\n",
+    "\n",
+    "The problem with a 10,000 layer neural network is that if and when you get to the 10,000th word of the dataset, you will still need to calculate the derivatives all the way back to the first layer. This is going to be very slow indeed, and very memory intensive. It is unlikely that you could store even one mini batch on your GPU.\n",
+    "\n",
+    "The solution to this is to tell PyTorch that we do not want to back propagate the derivatives through the entire implicit neural network. Instead, we will just keep the last three layers of gradients. To remove all of the gradient history in PyTorch, we use the `detach` method.\n",
+    "\n",
+    "Here is the new version of our RNN. It is now stateful, because it remembers its activations between different calls to `forward`, which represent its use for different samples in the batch:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class LMModel3(Module):\n",
+    "    def __init__(self, vocab_sz, n_hidden):\n",
+    "        self.i_h = nn.Embedding(vocab_sz, n_hidden)  \n",
+    "        self.h_h = nn.Linear(n_hidden, n_hidden)     \n",
+    "        self.h_o = nn.Linear(n_hidden,vocab_sz)\n",
+    "        self.h = 0\n",
+    "        \n",
+    "    def forward(self, x):\n",
+    "        for i in range(3):\n",
+    "            self.h = self.h + self.i_h(x[:,i])\n",
+    "            self.h = F.relu(self.h_h(self.h))\n",
+    "        out = self.h_o(self.h)\n",
+    "        self.h = self.h.detach()\n",
+    "        return out\n",
+    "    \n",
+    "    def reset(self): self.h = 0"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "If you think about it, this model will have the same activations whatever the sequence length we pick, because the hidden state will remember the last activation from the previous batch. The only thing that will be different are the gradients computed at each step: they will only be calculated on sequence length tokens in the past, instead of the whole stream. That is why this sequence length is often called *bptt* for back-propagation through time."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "* jargon: Back propagation through time (BPTT): Treating a neural net with effectively one layer per time step (usually refactored using a loop) as one big model, and calculating gradients on it in the usual way. To avoid running out of memory and time, we usually use _truncated_ BPTT, which \"detaches\" the history of computation steps in the hidden state every few time steps."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To use `LMModel3`, we need to make sure the samples are going to be seen in a certain order. As we saw in <<chapter_nlp>>, if the first line of the first batch is our `dset[0]` then the second batch should have `dset[1]` as the first line, so that the model sees the text flowing.\n",
+    "\n",
+    "`LMDataLoader` was doing this for us in <<chapter_nlp>>. This time we're going to do it ourselves.\n",
+    "\n",
+    "To do this, we are going to rearrange our dataset. First we divide the samples into `m = len(dset) // bs` groups (this is the equivalent of splitting the whole concatenated dataset into, for instance, 64 equally sized pieces, since we're using `bs=64` here). `m` is the length of each of these pieces. For instance, if we're using our whole dataset (although we'll actually split it into train vs valid in a moment), that will be:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(328, 64, 21031)"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "m = len(seqs)//bs\n",
+    "m,bs,len(seqs)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The first batch will be composed of the samples:\n",
+    "\n",
+    "    (0, m, 2*m, ..., (bs-1)*m)\n",
+    "\n",
+    "then the second batch of the samples: \n",
+    "\n",
+    "    (1, m+1, 2*m+1, ..., (bs-1)*m+1)\n",
+    "\n",
+    "and so forth. This way, at each epoch, the model will see a chunk of contiguous text of size `3*m` (since each text is of size 3) on each line of the batch.\n",
+    "\n",
+    "The following function does that reindexing:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def group_chunks(ds, bs):\n",
+    "    m = len(ds) // bs\n",
+    "    new_ds = L()\n",
+    "    for i in range(m): new_ds += L(ds[i + m*j] for j in range(bs))\n",
+    "    return new_ds"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Then we just pass `drop_last=True` when building our `DataLoaders` to drop the last batch that has not a shape of `bs`, we also pass `shuffle=False`  to make sure the texts are read in order."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cut = int(len(seqs) * 0.8)\n",
+    "dls = DataLoaders.from_dsets(\n",
+    "    group_chunks(seqs[:cut], bs), \n",
+    "    group_chunks(seqs[cut:], bs), \n",
+    "    bs=bs, drop_last=True, shuffle=False)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The last thing we add is a little tweak of the training loop via a `Callback`. We will talk more about callbacks in <<chapter_accel_sgd>>; this one will call the `reset` method of our model at the beginning of each epoch and before each validation phase. Since we implemented that method to zero the hidden state of the model, this will make sure we start we a clean state before reading those continuous chunks of text. We can also start training a bit longer:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: left;\">\n",
+       "      <th>epoch</th>\n",
+       "      <th>train_loss</th>\n",
+       "      <th>valid_loss</th>\n",
+       "      <th>accuracy</th>\n",
+       "      <th>time</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <td>0</td>\n",
+       "      <td>1.677074</td>\n",
+       "      <td>1.827367</td>\n",
+       "      <td>0.467548</td>\n",
+       "      <td>00:02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>1</td>\n",
+       "      <td>1.282722</td>\n",
+       "      <td>1.870913</td>\n",
+       "      <td>0.388942</td>\n",
+       "      <td>00:02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>2</td>\n",
+       "      <td>1.090705</td>\n",
+       "      <td>1.651793</td>\n",
+       "      <td>0.462500</td>\n",
+       "      <td>00:02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>3</td>\n",
+       "      <td>1.005092</td>\n",
+       "      <td>1.613794</td>\n",
+       "      <td>0.516587</td>\n",
+       "      <td>00:02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>4</td>\n",
+       "      <td>0.965975</td>\n",
+       "      <td>1.560775</td>\n",
+       "      <td>0.551202</td>\n",
+       "      <td>00:02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>5</td>\n",
+       "      <td>0.916182</td>\n",
+       "      <td>1.595857</td>\n",
+       "      <td>0.560577</td>\n",
+       "      <td>00:02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>6</td>\n",
+       "      <td>0.897657</td>\n",
+       "      <td>1.539733</td>\n",
+       "      <td>0.574279</td>\n",
+       "      <td>00:02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>7</td>\n",
+       "      <td>0.836274</td>\n",
+       "      <td>1.585141</td>\n",
+       "      <td>0.583173</td>\n",
+       "      <td>00:02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>8</td>\n",
+       "      <td>0.805877</td>\n",
+       "      <td>1.629808</td>\n",
+       "      <td>0.586779</td>\n",
+       "      <td>00:02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>9</td>\n",
+       "      <td>0.795096</td>\n",
+       "      <td>1.651267</td>\n",
+       "      <td>0.588942</td>\n",
+       "      <td>00:02</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "learn = Learner(dls, LMModel3(len(vocab), 64), loss_func=F.cross_entropy,\n",
+    "                metrics=accuracy, cbs=ModelReseter)\n",
+    "learn.fit_one_cycle(10, 3e-3)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This is already better! The next step is to use more targets and compare them to the intermediate predictions."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Creating more signal"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Another problem with our current approach is that we only predict one output word for each three input words. That means that the amount of signal that we are feeding back to update weights with is not as large as it could be. It would be better if we predicted the next word after every single word, rather than every three words, as shown in <<stateful_rep>>."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<img alt=\"RNN predicting after every token\" width=\"400\" caption=\"RNN predicting after every token\" id=\"stateful_rep\" src=\"images/att_00024.png\">"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This is easy enough to add. We need to first change our data so that the dependent variable has each of the three next words after each of our three input words. Instead of 3, we use an attribute, `sl` (for sequence length) and make it a bit bigger:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sl = 16\n",
+    "seqs = L((tensor(nums[i:i+sl]), tensor(nums[i+1:i+sl+1]))\n",
+    "         for i in range(0,len(nums)-sl-1,sl))\n",
+    "cut = int(len(seqs) * 0.8)\n",
+    "dls = DataLoaders.from_dsets(group_chunks(seqs[:cut], bs),\n",
+    "                             group_chunks(seqs[cut:], bs),\n",
+    "                             bs=bs, drop_last=True, shuffle=False)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Looking at the first element of `seqs`, we can see that it contains two lists of the same size. The second list is the same as the first, but offset by one element:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[(#16) ['one','.','two','.','three','.','four','.','five','.'...],\n",
+       " (#16) ['.','two','.','three','.','four','.','five','.','six'...]]"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "[L(vocab[o] for o in s) for s in seqs[0]]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now we need to modify our model so that it outputs a prediction after every word, rather than just at the end of a three word sequence:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class LMModel4(Module):\n",
+    "    def __init__(self, vocab_sz, n_hidden):\n",
+    "        self.i_h = nn.Embedding(vocab_sz, n_hidden)  \n",
+    "        self.h_h = nn.Linear(n_hidden, n_hidden)     \n",
+    "        self.h_o = nn.Linear(n_hidden,vocab_sz)\n",
+    "        self.h = 0\n",
+    "        \n",
+    "    def forward(self, x):\n",
+    "        outs = []\n",
+    "        for i in range(sl):\n",
+    "            self.h = self.h + self.i_h(x[:,i])\n",
+    "            self.h = F.relu(self.h_h(self.h))\n",
+    "            outs.append(self.h_o(self.h))\n",
+    "        self.h = self.h.detach()\n",
+    "        return torch.stack(outs, dim=1)\n",
+    "    \n",
+    "    def reset(self): self.h = 0"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This model will return outputs of shape `bs x sl x vocab_sz` (since we stacked on `dim=1`). Our targets are of shape `bs x sl`, so we need to flatten those before using them in `F.cross_entropy`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def loss_func(inp, targ):\n",
+    "    return F.cross_entropy(inp.view(-1, len(vocab)), targ.view(-1))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can now use this loss function to train the model:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: left;\">\n",
+       "      <th>epoch</th>\n",
+       "      <th>train_loss</th>\n",
+       "      <th>valid_loss</th>\n",
+       "      <th>accuracy</th>\n",
+       "      <th>time</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <td>0</td>\n",
+       "      <td>3.103298</td>\n",
+       "      <td>2.874341</td>\n",
+       "      <td>0.212565</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>1</td>\n",
+       "      <td>2.231964</td>\n",
+       "      <td>1.971280</td>\n",
+       "      <td>0.462158</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>2</td>\n",
+       "      <td>1.711358</td>\n",
+       "      <td>1.813547</td>\n",
+       "      <td>0.461182</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>3</td>\n",
+       "      <td>1.448516</td>\n",
+       "      <td>1.828176</td>\n",
+       "      <td>0.483236</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>4</td>\n",
+       "      <td>1.288630</td>\n",
+       "      <td>1.659564</td>\n",
+       "      <td>0.520671</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>5</td>\n",
+       "      <td>1.161470</td>\n",
+       "      <td>1.714023</td>\n",
+       "      <td>0.554932</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>6</td>\n",
+       "      <td>1.055568</td>\n",
+       "      <td>1.660916</td>\n",
+       "      <td>0.575033</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>7</td>\n",
+       "      <td>0.960765</td>\n",
+       "      <td>1.719624</td>\n",
+       "      <td>0.591064</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>8</td>\n",
+       "      <td>0.870153</td>\n",
+       "      <td>1.839560</td>\n",
+       "      <td>0.614665</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>9</td>\n",
+       "      <td>0.808545</td>\n",
+       "      <td>1.770278</td>\n",
+       "      <td>0.624349</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>10</td>\n",
+       "      <td>0.758084</td>\n",
+       "      <td>1.842931</td>\n",
+       "      <td>0.610758</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>11</td>\n",
+       "      <td>0.719320</td>\n",
+       "      <td>1.799527</td>\n",
+       "      <td>0.646566</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>12</td>\n",
+       "      <td>0.683439</td>\n",
+       "      <td>1.917928</td>\n",
+       "      <td>0.649821</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>13</td>\n",
+       "      <td>0.660283</td>\n",
+       "      <td>1.874712</td>\n",
+       "      <td>0.628581</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>14</td>\n",
+       "      <td>0.646154</td>\n",
+       "      <td>1.877519</td>\n",
+       "      <td>0.640055</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "learn = Learner(dls, LMModel4(len(vocab), 64), loss_func=loss_func,\n",
+    "                metrics=accuracy, cbs=ModelReseter)\n",
+    "learn.fit_one_cycle(15, 3e-3)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We need to train for longer, since the task has changed a bit and is more complicated now. But we end up with a good result... At least, sometimes. If you run it a few times, you'll see that you can get quite different results on different runs. That's because effectively we have a very deep network here, which can result in very large or very small gradients. We'll see in the next part of to deal with this.\n",
+    "\n",
+    "Now, the obvious way to get a better model is to go deeper: we only have one linear layer between the hidden state and the output activations in our basic RNN, so maybe we would get better results with more."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Multilayer RNNs"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In a multilayer RNN, we pass the activations from our recurrent neural network into a second recurrent neural network, like in <<stacked_rnn_rep>>."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<img alt=\"2-layer RNN\" width=\"550\" caption=\"2-layer RNN\" id=\"stacked_rnn_rep\" src=\"images/att_00025.png\">"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "…or in an unrolled representation in <<unrolled_stack_rep>> (the same way as in <<lm_rep>> last section)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<img alt=\"2-layer unrolled RNN\" width=\"500\" caption=\"2-layer unrolled RNN\" id=\"unrolled_stack_rep\" src=\"images/att_00026.png\">"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's see how to implement this in practice."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## The model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's save some time by using PyTorch's RNN class, which implements exactly what we have created above, but also gives us the option to stack multiple RNNs, as we have discussed:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class LMModel5(Module):\n",
+    "    def __init__(self, vocab_sz, n_hidden, n_layers):\n",
+    "        self.i_h = nn.Embedding(vocab_sz, n_hidden)\n",
+    "        self.rnn = nn.RNN(n_hidden, n_hidden, n_layers, batch_first=True)\n",
+    "        self.h_o = nn.Linear(n_hidden, vocab_sz)\n",
+    "        self.h = torch.zeros(n_layers, bs, n_hidden)\n",
+    "        \n",
+    "    def forward(self, x):\n",
+    "        res,h = self.rnn(self.i_h(x), self.h)\n",
+    "        self.h = h.detach()\n",
+    "        return self.h_o(res)\n",
+    "    \n",
+    "    def reset(self): self.h.zero_()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: left;\">\n",
+       "      <th>epoch</th>\n",
+       "      <th>train_loss</th>\n",
+       "      <th>valid_loss</th>\n",
+       "      <th>accuracy</th>\n",
+       "      <th>time</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <td>0</td>\n",
+       "      <td>3.055853</td>\n",
+       "      <td>2.591640</td>\n",
+       "      <td>0.437907</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>1</td>\n",
+       "      <td>2.162359</td>\n",
+       "      <td>1.787310</td>\n",
+       "      <td>0.471598</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>2</td>\n",
+       "      <td>1.710663</td>\n",
+       "      <td>1.941807</td>\n",
+       "      <td>0.321777</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>3</td>\n",
+       "      <td>1.520783</td>\n",
+       "      <td>1.999726</td>\n",
+       "      <td>0.312012</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>4</td>\n",
+       "      <td>1.330846</td>\n",
+       "      <td>2.012902</td>\n",
+       "      <td>0.413249</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>5</td>\n",
+       "      <td>1.163297</td>\n",
+       "      <td>1.896192</td>\n",
+       "      <td>0.450684</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>6</td>\n",
+       "      <td>1.033813</td>\n",
+       "      <td>2.005209</td>\n",
+       "      <td>0.434814</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>7</td>\n",
+       "      <td>0.919090</td>\n",
+       "      <td>2.047083</td>\n",
+       "      <td>0.456706</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>8</td>\n",
+       "      <td>0.822939</td>\n",
+       "      <td>2.068031</td>\n",
+       "      <td>0.468831</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>9</td>\n",
+       "      <td>0.750180</td>\n",
+       "      <td>2.136064</td>\n",
+       "      <td>0.475098</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>10</td>\n",
+       "      <td>0.695120</td>\n",
+       "      <td>2.139140</td>\n",
+       "      <td>0.485433</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>11</td>\n",
+       "      <td>0.655752</td>\n",
+       "      <td>2.155081</td>\n",
+       "      <td>0.493652</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>12</td>\n",
+       "      <td>0.629650</td>\n",
+       "      <td>2.162583</td>\n",
+       "      <td>0.498535</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>13</td>\n",
+       "      <td>0.613583</td>\n",
+       "      <td>2.171649</td>\n",
+       "      <td>0.491048</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>14</td>\n",
+       "      <td>0.604309</td>\n",
+       "      <td>2.180355</td>\n",
+       "      <td>0.487874</td>\n",
+       "      <td>00:01</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "learn = Learner(dls, LMModel5(len(vocab), 64, 2), loss_func=CrossEntropyLossFlat(), \n",
+    "                metrics=accuracy, cbs=ModelReseter)\n",
+    "learn.fit_one_cycle(15, 3e-3)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now that's disappointing... we are doing more poorly than the single-layer RNN from the end of last section. The reason is that we have a deeper model, leading to exploding or disappearing activations."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Exploding or disappearing activations"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In practice, creating accurate models from this kind of RNN is difficult. We will get better results if we call `detach` less often, and have more layers — this gives our RNN a longer time horizon to learn from, and richer features to create. But it also means we have a deeper model to train. The key challenge in the development of deep learning has been figuring out how to train these kinds of models.\n",
+    "\n",
+    "The reason this is challenging is because of what happens when you multiply by a matrix many times. Think about what happens when you multiply by a number many times. For example, if you multiply by two, starting at one, you get the sequence 1, 2, 4, 8,… after 32 steps you are already at 4,294,967,296. A similar issue happens if we multiply by 0.5: we get 0.5, 0.25, 0.125… and after 32 steps it's 0.00000000023. As you can see, a number even slightly higher or lower than one results in an explosion or disappearance of our number, after just a few repeated multiplications.\n",
+    "\n",
+    "Because matrix multiplication is just multiplying numbers and adding them up, exactly the same thing happens with repeated matrix multiplications. And a deep neural network is just repeated matrix multiplications--each extra layer is another matrix multiplication. This means that it is very easy for a deep neural network to end up with extremely large, or extremely small numbers.\n",
+    "\n",
+    "This is a problem, because the way computers store numbers (known as \"floating point\") means that they become less and less accurate the further away the numbers get from zero. The diagram in <<float_prec>>, from the excellent article [What you never wanted to know about floating point but will be forced to find out](http://www.volkerschatz.com/science/float.html), shows how the precision of floating point numbers varies over the number line:"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<img alt=\"Precision of floating point numbers\" width=\"1000\" caption=\"Precision of floating point numbers\" id=\"float_prec\" src=\"images/fltscale.svg\">"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This inaccuracy means that often the gradients calculated for updating the weights end up as zero or infinity for deep networks. This is commonly refered to as *vanishing gradients* or *exploding gradients*. That means that in SGD, the weights are updated either not at all, or jump to infinity. Either way, they won't improve with training.\n",
+    "\n",
+    "Researchers have developed a number of ways to tackle this problem, which we will be discussing later in the book. One way to tackle the problem is to change the definition of a layer in a way that makes it less likely to have exploding activations. We'll look at the details of how this is done in <<chapter_convolutions>>, when we discuss *batch normalization*, and <<chapter_resnet>>, when we discuss *ResNets*, although these details don't generally matter in practice (unless you are a researcher that is creating new approaches to solving this problem). Another way to deal with this is by being careful about *initialization*, which is a topic we'll investigate in <<chapter_foundations>>.\n",
+    "\n",
+    "For RNNs, there are two types of layers frequently used to avoid exploding activations, and they are: *gated recurrent units* (GRU), and *Long Short-Term Memory* (LSTM). Both of these are available in PyTorch, and are drop-in replacements for the RNN layer. We will only cover LSTMs in this book, there are plenty of good tutorials online explaining GRUs, which are a minor variant on the LSTM design."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## LSTM"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "LSTM (for long short-term memory) is an architecture that was introduced back in 1997 by Jurgen Schmidhuber and Sepp Hochreiter. In this architecture, there are not one but two hidden states. In our base RNN, the hidden state is the output of the RNN at the previous time step. That hidden state is then responsible for doing two things at a time:\n",
+    "\n",
+    "- having the right information for the output layer to predict the correct next token\n",
+    "- retaining memory of everything that happened in the sentence\n",
+    "\n",
+    "Consider, for example, the sentences \"Henry has a dog and he likes his dog very much\" and \"Sophie has a dog and she likes her dog very much\". It's very clear that the RNN needs to remember the name at the beginning of the sentence to be able to predict *he/she* or *his/her*. \n",
+    "\n",
+    "In practice, RNNs are really bad at retaining memory of what happened much earlier in the sentence, which is the motivation to have another hidden state (called cell state) in the LSTM. The cell state will be responsible for keeping *long short-term memory*, while the hidden state will focus on the next token to predict. Let's have a closer look and how this is achieved and build one LSTM from scratch."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Building an LSTM from scratch"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In order to build an LSTM, we first have to understand its architecture. <<lstm>> shows us its inner structure.\n",
+    "    \n",
+    "<img src=\"images/LSTM.png\" id=\"lstm\" caption=\"Architecture of an LSTM\" alt=\"A graph showing the inner architecture of an LSTM\" width=\"700\">"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In this picture, our input $x_{t}$ enters on the bottom with the previous hidden state ($h_{t-1}$) and cell state ($x_{t-1}$). The four orange boxes represent four layers with the activation being either sigmoid (for $\\sigma$) or tanh. tanh is just a sigmoid rescaled to the range -1 to 1. Its mathematical expression can be written like this:\n",
+    "\n",
+    "$$\\tanh(x) = \\frac{e^{x} + e^{-x}}{e^{x}-e^{-x}} = 2 \\sigma(2x) - 1$$\n",
+    "\n",
+    "where $\\sigma$ is the sigmoid function. The green boxes are elementwise operations. What goes out is the new hidden state ($h_{t}$) and new cell state ($c_{t}$) on the left, ready for our next input. The new hidden state is also use as output, which is why the arrow splits to go up.\n",
+    "\n",
+    "Let's go over the four neural nets (called *gates*) one by one and explain the diagram, but before this, notice how very little the cell state (on the top) is changed. It doesn't even go directly through a neural net! This is exactly why it will carry on a longer-term state.\n",
+    "\n",
+    "First, the arrows for input and old hidden state are joined together. In the RNN we wrote before in this chapter, we were adding them together. In the LSTM, we stack them in one big tensor. This means the dimension of our embeddings (which is the dimension of $x_{t}$) can be different than the dimension of our hidden state. If we call those `n_in` and `n_hid`, the arrow at the bottom is of size `n_in + n_hid`, thus all the neural nets (orange boxes) are linear layers with `n_in + n_hid` inputs and `n_hid` outputs.\n",
+    "\n",
+    "The first gate (looking from the left to right) is called the *forget gate*. Since it's a linear layer followed by a sigmoid, its output will have scalars between 0 and 1. We multiply this result by the cell gate, so for all the values close to 0, we will forget what was inside that cell state (and for the values close to 1 it doesn't do anything). This gives the ability to the LSTM to forget things about its longterm state. For instance, when crossing a period or an `xxbos` token, we would expect to it to (have learned to) reset its cell state.\n",
+    "\n",
+    "The second gate is called the *input gate*. It works with the third gate (which doesn't really have a name but is sometimes called the *cell gate*) to update the cell state. For instance we may see a new gender pronoun, so we must replace the information about gender that the forget gate removed by the new one. Like the forget gate, the input gate ends up on a product, so it jsut decides which element of the cell state to update (valeus close to 1) or not (values close to 0). The third gate will then fill those values with things between -1 and 1 (thanks to the tanh). The result is then added to the cell state.\n",
+    "\n",
+    "The last gate is the *output gate*. It will decides which information take in the cell state to generate the output. The cell state goes through a tanh before this and the output gate combined with the sigmoid decides which values to take inside it.\n",
+    "\n",
+    "\n",
+    "In terms of code, we can write the same steps like this:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class LSTMCell(Module):\n",
+    "    def __init__(self, ni, nh):\n",
+    "        self.forget_gate = nn.Linear(ni + nh, nh)\n",
+    "        self.input_gate  = nn.Linear(ni + nh, nh)\n",
+    "        self.cell_gate   = nn.Linear(ni + nh, nh)\n",
+    "        self.output_gate = nn.Linear(ni + nh, nh)\n",
+    "\n",
+    "    def forward(self, input, state):\n",
+    "        h,c = state\n",
+    "        h = torch.stack([h, input], dim=1)\n",
+    "        forget = torch.sigmoid(self.forget_gate(h))\n",
+    "        c = c * forget\n",
+    "        inp = torch.sigmoid(self.input_gate(h))\n",
+    "        cell = torch.tanh(self.cell_gate(h))\n",
+    "        c = c + inp * cell\n",
+    "        out = torch.sigmoid(self.output_gate(h))\n",
+    "        h = outgate * torch.tanh(c)\n",
+    "        return h, (h,c)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In practice, we can then refactor the code. Also, in terms of performance, it's better to do one big matrix multiplication than four smaller ones (that's because we only launch the special fast kernel on GPU once, and it gives the GPU more work to do in parallel). The stacking takes a bit of time (since we have to move one of the tensors around on the GPU to have it all in a contiguous array), so we use two separate layers for the input and the hidden state. The optimized and refactored code then looks like that:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class LSTMCell(Module):\n",
+    "    def __init__(self, ni, nh):\n",
+    "        self.ih = nn.Linear(ni,4*nh)\n",
+    "        self.hh = nn.Linear(nh,4*nh)\n",
+    "\n",
+    "    def forward(self, input, state):\n",
+    "        h,c = state\n",
+    "        #One big multiplication for all the gates is better than 4 smaller ones\n",
+    "        gates = (self.ih(input) + self.hh(h)).chunk(4, 1)\n",
+    "        ingate,forgetgate,outgate = map(torch.sigmoid, gates[:3])\n",
+    "        cellgate = gates[3].tanh()\n",
+    "\n",
+    "        c = (forgetgate*c) + (ingate*cellgate)\n",
+    "        h = outgate * c.tanh()\n",
+    "        return h, (h,c)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here we use the PyTorch `chunk` method to split our tensor into 4 pieces, e.g.:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "tensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "t = torch.arange(0,10); t"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(tensor([0, 1, 2, 3, 4]), tensor([5, 6, 7, 8, 9]))"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "t.chunk(2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's now use this architecture to train a language model!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Training a language model using LSTMs"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here is the same network as `LMModel5`, using a two-layer LSTM. We can train it at a higher learning rate, for a shorter time, and get better accuracy:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class LMModel6(Module):\n",
+    "    def __init__(self, vocab_sz, n_hidden, n_layers):\n",
+    "        self.i_h = nn.Embedding(vocab_sz, n_hidden)\n",
+    "        self.rnn = nn.LSTM(n_hidden, n_hidden, n_layers, batch_first=True)\n",
+    "        self.h_o = nn.Linear(n_hidden, vocab_sz)\n",
+    "        self.h = [torch.zeros(2, bs, n_hidden) for _ in range(n_layers)]\n",
+    "        \n",
+    "    def forward(self, x):\n",
+    "        res,h = self.rnn(self.i_h(x), self.h)\n",
+    "        self.h = [h_.detach() for h_ in h]\n",
+    "        return self.h_o(res)\n",
+    "    \n",
+    "    def reset(self): \n",
+    "        for h in self.h: h.zero_()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: left;\">\n",
+       "      <th>epoch</th>\n",
+       "      <th>train_loss</th>\n",
+       "      <th>valid_loss</th>\n",
+       "      <th>accuracy</th>\n",
+       "      <th>time</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <td>0</td>\n",
+       "      <td>3.000821</td>\n",
+       "      <td>2.663942</td>\n",
+       "      <td>0.438314</td>\n",
+       "      <td>00:02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>1</td>\n",
+       "      <td>2.139642</td>\n",
+       "      <td>2.184780</td>\n",
+       "      <td>0.240479</td>\n",
+       "      <td>00:02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>2</td>\n",
+       "      <td>1.607275</td>\n",
+       "      <td>1.812682</td>\n",
+       "      <td>0.439779</td>\n",
+       "      <td>00:02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>3</td>\n",
+       "      <td>1.347711</td>\n",
+       "      <td>1.830982</td>\n",
+       "      <td>0.497477</td>\n",
+       "      <td>00:02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>4</td>\n",
+       "      <td>1.123113</td>\n",
+       "      <td>1.937766</td>\n",
+       "      <td>0.594401</td>\n",
+       "      <td>00:02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>5</td>\n",
+       "      <td>0.852042</td>\n",
+       "      <td>2.012127</td>\n",
+       "      <td>0.631592</td>\n",
+       "      <td>00:02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>6</td>\n",
+       "      <td>0.565494</td>\n",
+       "      <td>1.312742</td>\n",
+       "      <td>0.725749</td>\n",
+       "      <td>00:02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>7</td>\n",
+       "      <td>0.347445</td>\n",
+       "      <td>1.297934</td>\n",
+       "      <td>0.711263</td>\n",
+       "      <td>00:02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>8</td>\n",
+       "      <td>0.208191</td>\n",
+       "      <td>1.441269</td>\n",
+       "      <td>0.731201</td>\n",
+       "      <td>00:02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>9</td>\n",
+       "      <td>0.126335</td>\n",
+       "      <td>1.569952</td>\n",
+       "      <td>0.737305</td>\n",
+       "      <td>00:02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>10</td>\n",
+       "      <td>0.079761</td>\n",
+       "      <td>1.427187</td>\n",
+       "      <td>0.754150</td>\n",
+       "      <td>00:02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>11</td>\n",
+       "      <td>0.052990</td>\n",
+       "      <td>1.494990</td>\n",
+       "      <td>0.745117</td>\n",
+       "      <td>00:02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>12</td>\n",
+       "      <td>0.039008</td>\n",
+       "      <td>1.393731</td>\n",
+       "      <td>0.757894</td>\n",
+       "      <td>00:02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>13</td>\n",
+       "      <td>0.031502</td>\n",
+       "      <td>1.373210</td>\n",
+       "      <td>0.758464</td>\n",
+       "      <td>00:02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>14</td>\n",
+       "      <td>0.028068</td>\n",
+       "      <td>1.368083</td>\n",
+       "      <td>0.758464</td>\n",
+       "      <td>00:02</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "learn = Learner(dls, LMModel6(len(vocab), 64, 2), loss_func=CrossEntropyLossFlat(), \n",
+    "                metrics=accuracy, cbs=ModelReseter)\n",
+    "learn.fit_one_cycle(15, 1e-2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now that's better than a multilayer RNN! We can still see there is a bit of overfitting, which is a sign that a bit of regularization might help."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Regularizing an LSTM"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Recurrent neural networks, in general, are hard to train, because of the problems of vanishing activations and gradients we saw before. Using LSTMs (or GRUs) cell make training easier than vanilla RNNs, but there are still very prone to overfitting. Data augmentation, while it exists for text data, is less often used because in most cases, it requires another model to generate random augmentation (by translating in another language and back to the language used for instance). Overall, data augmentation for text data is currently not a well explored space.\n",
+    "\n",
+    "However, there are other regularization techniques we can use instead to reduce overfitting, which were thoroughly studied for use with LSTMs in the paper [Regularizing and Optimizing LSTM Language Models](https://arxiv.org/abs/1708.02182). This paper showed how effective use of *dropout*, *activation regularization*, and *temporal activation regularization* could allow an LSTM to beat state of the art results that previously required much more complicated models. They called an LSTM using these techniques an *AWD LSTM*. We'll look at each of these techniques in turn."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Dropout"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Dropout is a regularization technique that was introduce by Geoffrey Hinton et al. in [Improving neural networks by preventing co-adaptation of feature detectors](https://arxiv.org/abs/1207.0580). The basic idea is to randomly change some activations to zero at training time. This makes sure all neurons actively work toward the output as seen in <<img_dropout>> which is a screenshot from the original paper.\n",
+    "\n",
+    "<img src=\"images/Dropout1.png\" alt=\"A figure from the article showing how neurons go off with dropout\" width=\"800\" id=\"img_dropout\" caption=\"A screenshot from the dropout paper\">\n",
+    "\n",
+    "Hinton used a nice metaphor when he explained, in an interview, the inspiration for dropout:\n",
+    "\n",
+    "> : \"I went to my bank. The tellers kept changing and I asked one of them why. He said he didn’t know but they got moved around a lot. I figured it must be because it would require cooperation between employees to successfully defraud the bank. This made me realize that randomly removing a different subset of neurons on each example would prevent conspiracies and thus reduce overfitting\"\n",
+    "\n",
+    "In the same interview, he also explained that neuroscience provided additional inspiration:\n",
+    "\n",
+    "> : \"We don't really know why neurons spike. One theory is that they want to be noisy so as to regularize, because we have many more parameters than we have data points. The idea of dropout is that if you have noisy activations, you can afford to use a much bigger model.\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "TK add takeaway form those citations before moving on."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can see there that if we just zero those activations without doing anything else, our model will have problems to train: if we go from the sum of 5 activations (that are all positive numbers since we apply a ReLU) to just 2, this won't have the same scale. Therefore if we dropout with a probability `p`, we rescale all activation by dividing them by `1-p` (on average `p` will be zeroed, so it leaves `1-p`), as shown in <<img_dropout1>> which is a diagram from the original paper.\n",
+    "\n",
+    "<img src=\"images/Dropout.png\" alt=\"A figure from the article introducing dropout showing how a neuron is on/off\" width=\"600\" id=\"img_dropout1\" cpation=\"Why scale the activations when applying dropout\">\n",
+    "\n",
+    "This is a full implementation of the dropout layer in PyTorch (although PyTorch's native layer is actually written in C, not Python):"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class Dropout(Module):\n",
+    "    def __init__(self, p): self.p = p\n",
+    "    def forward(self, x):\n",
+    "        if not self.training: return x\n",
+    "        mask = x.new(*x.shape).bernoulli_(1-p)\n",
+    "        return x * mask.div_(1-p)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The `bernoulli_` method is creating a tensor with random zeros (with probability p) and ones (with probability 1-p), which is then multiplied with our input before dividing by `1-p`. Note the use of the `training` attribute, which is available in any PyTorch `nn.Module`, and tells us if we are doing training or inference.\n",
+    "\n",
+    "> note: In previous chapters of the book we'd be adding a code example for `bernoulli_` here, so you can see exactly how it works. But now that you know enough to do this yourself, we're going to be doing fewer and fewer examples for you, and instead expecting you to do your own experiments to see how things work. In this case, you'll see in the end-of-chapter questionnaire that we're asking you to experiment with `bernoulli_`--but don't wait for us to ask you to experiment to develop your understanding of the code we're studying, go ahead and do it anyway!\n",
+    "\n",
+    "Using dropout before passing the output of our LSTM to the final layer will help reduce overfitting. Dropout is also used in many other models, including the default CNN head used in `fastai.vision`, and is also available in `fastai.tabular` by passing the `ps` parameter (where each \"p\" is passed to each added `Dropout` layer), as we'll see in <<chapter_arch_details>>."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Dropout has a different behavior in training and validation mode, which we achieved using the `training` attribute in `Dropout` above. Calling the `train()` method on a `Module` sets `training` to `True` (both for the module you call the method on, and for every module it recursively contains), and `eval()` sets it to `False`. This is done automatically when calling the methods of `Learner`, but if you are not using that class, remember to switch from one to the other as needed."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### AR and TAR regularization"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "AR (for *activation regularization*) and TAR (for *temporal activation regularization*) are two regularization methods very similar to weight decay. When applying weight decay, we add a small penalty to the loss that aims at making the weights as small as possible. For the activation regularization, it's the final activations produced by the LSTM that we will try to make as small as possible, instead of the weights.\n",
+    "\n",
+    "To regularize the final activations, we have to store those somewhere, then add the means of the squares of them to the loss (along with a multiplier `alpha`, which is just like `wd` for weight decay):\n",
+    "\n",
+    "``` python\n",
+    "loss += alpha * activations.pow(2).mean()\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Temporal activation regularization is linked to the fact we are predicting tokens in a sentence. That means it's likely that the outputs of our LSTMs should somewhat make sense when we read them in order. TAR is there to encourage that behavior by adding a penalty to the loss to make the difference between two consecutive activations as small as possible: our activations tensor has a shape `bs x sl x n_hid`, and we read consecutive activation on the sequence length axis (so the dimension in the middle). With this, TAR can be expressed as:\n",
+    "\n",
+    "``` python\n",
+    "loss += beta * (activations[:,1:] - activations[:,:-1]).pow(2).mean()\n",
+    "```\n",
+    "\n",
+    "`alpha` and `beta` are then two hyper-parameters to tune. To make this work, we need our model with dropout to return three things: the proper output, the activations of the LSTM pre-dropout and the activations of the LSTM post-dropout. AR is often applied on the dropped out activations (to not penalize the activations we turned in 0s afterward) while TAR is applied on the non-dropped out activations (because those 0s create big differences between two consecutive timesteps). There is then a callback called `RNNRegularizer` that will apply this regularization for us."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Training a weight-tied regularized LSTM"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can combine dropout (applied before we go in our output layer) with the AR and TAR regularization to train our previous LSTM. We just need to return three things instead of one: the normal output of our LSTM, the dropped-out activations and the activations from our LSTMs. Those last two will be picked up by the callback `RNNRegularization` for the contributions it has to make to the loss.\n",
+    "\n",
+    "Another useful trick we can add from the AWD LSTM paper is *weight tying*. In a language model, the input embeddings represent a mapping from English words to activations, and the output hidden layer represents a mapping from activations to English words. We might expect, intuitively, that these mappings could be the same. We can represent this in PyTorch by assigning the same weight matrix to each of these layers:\n",
+    "\n",
+    "    self.h_o.weight = self.i_h.weight\n",
+    "\n",
+    "In `LMMModel7`, we include these final tweaks:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class LMModel7(Module):\n",
+    "    def __init__(self, vocab_sz, n_hidden, n_layers, p):\n",
+    "        self.i_h = nn.Embedding(vocab_sz, n_hidden)\n",
+    "        self.rnn = nn.LSTM(n_hidden, n_hidden, n_layers, batch_first=True)\n",
+    "        self.drop = nn.Dropout(p)\n",
+    "        self.h_o = nn.Linear(n_hidden, vocab_sz)\n",
+    "        self.h_o.weight = self.i_h.weight\n",
+    "        self.h = [torch.zeros(2, bs, n_hidden) for _ in range(n_layers)]\n",
+    "        \n",
+    "    def forward(self, x):\n",
+    "        raw,h = self.rnn(self.i_h(x), self.h)\n",
+    "        out = self.drop(raw)\n",
+    "        self.h = [h_.detach() for h_ in h]\n",
+    "        return self.h_o(out),raw,out\n",
+    "    \n",
+    "    def reset(self): \n",
+    "        for h in self.h: h.zero_()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can create a regularized `Learner` using the `RNNRegularizer` callback:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "learn = Learner(dls, LMModel7(len(vocab), 64, 2, 0.5),\n",
+    "                loss_func=CrossEntropyLossFlat(), metrics=accuracy,\n",
+    "                cbs=[ModelReseter, RNNRegularizer(alpha=2, beta=1)])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "A `TextLearner` automatically adds those two callbacks for us (with default for `alpha` and `beta` as above) so we can simplify the line above to:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "learn = TextLearner(dls, LMModel7(len(vocab), 64, 2, 0.4),\n",
+    "                    loss_func=CrossEntropyLossFlat(), metrics=accuracy)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can the train the model, and add additional regularization by increasing the weight decay to `0.1`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: left;\">\n",
+       "      <th>epoch</th>\n",
+       "      <th>train_loss</th>\n",
+       "      <th>valid_loss</th>\n",
+       "      <th>accuracy</th>\n",
+       "      <th>time</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <td>0</td>\n",
+       "      <td>2.693885</td>\n",
+       "      <td>2.013484</td>\n",
+       "      <td>0.466634</td>\n",
+       "      <td>00:02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>1</td>\n",
+       "      <td>1.685549</td>\n",
+       "      <td>1.187310</td>\n",
+       "      <td>0.629313</td>\n",
+       "      <td>00:02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>2</td>\n",
+       "      <td>0.973307</td>\n",
+       "      <td>0.791398</td>\n",
+       "      <td>0.745605</td>\n",
+       "      <td>00:02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>3</td>\n",
+       "      <td>0.555823</td>\n",
+       "      <td>0.640412</td>\n",
+       "      <td>0.794108</td>\n",
+       "      <td>00:02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>4</td>\n",
+       "      <td>0.351802</td>\n",
+       "      <td>0.557247</td>\n",
+       "      <td>0.836100</td>\n",
+       "      <td>00:02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>5</td>\n",
+       "      <td>0.244986</td>\n",
+       "      <td>0.594977</td>\n",
+       "      <td>0.807292</td>\n",
+       "      <td>00:02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>6</td>\n",
+       "      <td>0.192231</td>\n",
+       "      <td>0.511690</td>\n",
+       "      <td>0.846761</td>\n",
+       "      <td>00:02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>7</td>\n",
+       "      <td>0.162456</td>\n",
+       "      <td>0.520370</td>\n",
+       "      <td>0.858073</td>\n",
+       "      <td>00:02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>8</td>\n",
+       "      <td>0.142664</td>\n",
+       "      <td>0.525918</td>\n",
+       "      <td>0.842285</td>\n",
+       "      <td>00:02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>9</td>\n",
+       "      <td>0.128493</td>\n",
+       "      <td>0.495029</td>\n",
+       "      <td>0.858073</td>\n",
+       "      <td>00:02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>10</td>\n",
+       "      <td>0.117589</td>\n",
+       "      <td>0.464236</td>\n",
+       "      <td>0.867188</td>\n",
+       "      <td>00:02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>11</td>\n",
+       "      <td>0.109808</td>\n",
+       "      <td>0.466550</td>\n",
+       "      <td>0.869303</td>\n",
+       "      <td>00:02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>12</td>\n",
+       "      <td>0.104216</td>\n",
+       "      <td>0.455151</td>\n",
+       "      <td>0.871826</td>\n",
+       "      <td>00:02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>13</td>\n",
+       "      <td>0.100271</td>\n",
+       "      <td>0.452659</td>\n",
+       "      <td>0.873617</td>\n",
+       "      <td>00:02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>14</td>\n",
+       "      <td>0.098121</td>\n",
+       "      <td>0.458372</td>\n",
+       "      <td>0.869385</td>\n",
+       "      <td>00:02</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "learn.fit_one_cycle(15, 1e-2, wd=0.1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now this is far better than our previous model!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Conclusion"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You have now seen everything that is inside the AWD-LSTM architecture we used in text classification in <<chapter_nlp>>. It uses dropouts in a lot more places:\n",
+    "\n",
+    "- embedding dropout (just after the embedding layer)\n",
+    "- input dropout (after the embedding layer)\n",
+    "- weight dropout (applied to the weights of the LSTM at each training step)\n",
+    "- hidden dropout (applied to the hidden state between two layers)\n",
+    "\n",
+    "which makes it even more regularized. Since fine-tuning those five dropout values (adding the dropout before the output layer) is complicated, so we have determined good defaults, and allow the magnitude of dropout to be tuned overall with the `drop_mult` parameter you saw (which is multiplied by each dropout).\n",
+    "\n",
+    "Another architecture that is very powerful, especially in \"sequence to sequence\" problems (that is, problems where the dependent variable is itself a variable length sequence, such as language translation), is the Transformers architecture. You can find it in an online bonus chapter on the book website."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Questionnaire"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "1. If the dataset for your project is so big and complicated that working with it takes a significant amount of time, what should you do?\n",
+    "1. Why do we concatenating the documents in our dataset before creating a language model?\n",
+    "1. To use a standard fully connected network to predict the fourth word given the previous three words, what two tweaks do we need to make?\n",
+    "1. How can we share a weight matrix across multiple layers in PyTorch?\n",
+    "1. Write a module which predicts the third word given the previous two words of a sentence, without peeking.\n",
+    "1. What is a recurrent neural network?\n",
+    "1. What is hidden state?\n",
+    "1. What is the equivalent of hidden state in ` LMModel1`?\n",
+    "1. To maintain the state in an RNN why is it important to pass the text to the model in order?\n",
+    "1. What is an unrolled representation of an RNN?\n",
+    "1. Why can maintaining the hidden state in an RNN lead to memory and performance problems? How do we fix this problem?\n",
+    "1. What is BPTT?\n",
+    "1. Write code to print out the first few batches of the validation set, including converting the token IDs back into English strings, as we showed for batches of IMDb data in <<chapter_nlp>>.\n",
+    "1. What does the `ModelReseter` callback do? Why do we need it?\n",
+    "1. What are the downsides of predicting just one output word for each three input words?\n",
+    "1. Why do we need a custom loss function for `LMModel4`?\n",
+    "1. Why is the training of `LMModel4` unstable?\n",
+    "1. In the unrolled representation, we can see that a recurrent neural network actually has many layers. So why do we need to stack RNNs to get better results?\n",
+    "1. Draw a representation of a stacked (multilayer) RNN.\n",
+    "1. Why should we get better results in an RNN if we call `detach` less often? Why might this not happen in practice with a simple RNN?\n",
+    "1. Why can a deep network result in very large or very small activations? Why does this matter?\n",
+    "1. In a computer's floating point representation of numbers, which numbers are the most precise?\n",
+    "1. Why do vanishing gradients prevent training?\n",
+    "1. Why does it help to have two hidden states in the LSTM architecture? What is the purpose of each one?\n",
+    "1. What are these two states called in an LSTM?\n",
+    "1. What is tanh, and how is it related to sigmoid?\n",
+    "1. What is the purpose of this code in `LSTMCell`?: `h = torch.stack([h, input], dim=1)`\n",
+    "1. What does `chunk` to in PyTorch?\n",
+    "1. Study the refactored version of `LSTMCell` carefully to ensure you understand how and why it does the same thing as the non-refactored version.\n",
+    "1. Why can we use a higher learning rate for `LMModel6`?\n",
+    "1. What are the three regularisation techniques used in an AWD-LSTM model?\n",
+    "1. What is dropout?\n",
+    "1. Why do we scale the weights with dropout? Is this applied during training, inference, or both?\n",
+    "1. What is the purpose of this line from `Dropout`?: `if not self.training: return x`\n",
+    "1. Experiment with `bernoulli_` to understand how it works.\n",
+    "1. How do you set your model in training mode in PyTorch? In evaluation mode?\n",
+    "1. Write the equation for activation regularization (in maths or code, as you prefer). How is it different to weight decay?\n",
+    "1. Write the equation for temporal activation regularization (in maths or code, as you prefer). Why wouldn't we use this for computer vision problems?\n",
+    "1. What is \"weight tying\" in a language model?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Further research"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "1. In ` LMModel2` why can `forward` start with `h=0`? Why don't we need to say `h=torch.zeros(…)`?\n",
+    "1. Write the code for an LSTM from scratch (but you may refer to <<lstm>>).\n",
+    "1. Search on the Internet for the GRU architecture and implement it from scratch, and try training a model. See if you can get the similar results as we saw in this chapter. Compare it to the results of PyTorch's built in GRU module.\n",
+    "1. Have a look at the source code for AWD-LSTM in fastai, and try to map each of the lines of code to the concepts shown in this chapter."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "jupytext": {
+   "split_at_heading": true
+  },
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/14_deep_conv.ipynb b/14_deep_conv.ipynb
deleted file mode 100644
index 87e1134..0000000
--- a/14_deep_conv.ipynb
+++ /dev/null
@@ -1,1044 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#hide\n",
-    "from utils import *"
-   ]
-  },
-  {
-   "cell_type": "raw",
-   "metadata": {},
-   "source": [
-    "[[chapter_deep_conv]]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Improving training stability"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Since we are so good at recognizing threes from sevens, let's move onto something harder—recognizing all 10 digits. That means we'll need to use `MNIST` instead of `MNIST_SAMPLE`:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "path = untar_data(URLs.MNIST)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#hide\n",
-    "Path.BASE_PATH = path"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(#2) [Path('testing'),Path('training')]"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "path.ls()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "The data is in two folders named `training` and `testing`, so we have to tell `GrandparentSplitter` about that (it defaults to `train` and `valid`). We define a function `get_dls` to make it easy to change our batch size later:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def get_dls(bs=64):\n",
-    "    return DataBlock(\n",
-    "        blocks=(ImageBlock(cls=PILImageBW), CategoryBlock), \n",
-    "        get_items=get_image_files, \n",
-    "        splitter=GrandparentSplitter('training','testing'),\n",
-    "        get_y=parent_label,\n",
-    "        batch_tfms=Normalize()\n",
-    "    ).dataloaders(path, bs=bs)\n",
-    "\n",
-    "dls = get_dls()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Always a good idea to look at your data before you use it:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 288x288 with 9 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "dls.show_batch(max_n=9, figsize=(4,4))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Now that we have our data ready, we can train a simple model on it."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## A simple baseline"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "In the previous chapter, we built a model based on a `conv` function like this:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def conv(ni, nf, ks=3, act=True):\n",
-    "    res = nn.Conv2d(ni, nf, stride=2, kernel_size=ks, padding=ks//2)\n",
-    "    if act: res = nn.Sequential(res, nn.ReLU())\n",
-    "    return res"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Let's start with a basic CNN as a baseline. We'll use the same as we had in the last chapter, but with one tweak: we'll use more activations.\n",
-    "\n",
-    "As we discussed, we generally want to double the number of filters each time we have a stride 2 layer. So, one way to increase the number of filters throughout our network is to double the number of activations in the first layer – then every layer after that will end up twice as big as the previous version as well.\n",
-    "\n",
-    "But there is a subtle problem with this. Consider the kernel which is being applied to each pixel. By default, we use a 3x3 pixel kernel. That means that there are a total of 3×3 = 9 pixels that the kernel is being applied to at each location. Previously, our first layer had four filters output. That meant that there were four values being computed from nine pixels at each location. Think about what happens if we double this output to 8 filters. Then when we apply our kernel we would be using nine pixels to calculate eight numbers. That means that it isn't really learning much at all — the output size is almost the same as the input size. Neural networks will only create useful features if they're forced to do so—that is, that the number of outputs from an operation is smaller than the number of inputs.\n",
-    "\n",
-    "To fix this, we can use a larger kernel in the first layer. If we use a kernel of 5x5 pixels then there are 25 pixels being used at each kernel application — creating eight filters from this will mean the neural net will have to find some useful features."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def simple_cnn():\n",
-    "    return sequential(\n",
-    "        conv(1 ,8, ks=5),        #14x14\n",
-    "        conv(8 ,16),             #7x7\n",
-    "        conv(16,32),             #4x4\n",
-    "        conv(32,64),             #2x2\n",
-    "        conv(64,10, act=False),  #1x1\n",
-    "        Flatten(),\n",
-    "    )"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "As you'll see in a moment, we're going to look inside our models while they're training in order to try to find ways to make them train better. To do this, we use the `ActivationStats` callback, which records the mean, standard deviation, and histogram of activations of every trainable layer (as we've seen, callbacks are used to add behavior to the training loop; we'll see how they work in <<chapter_callbacks>>)."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from fastai2.callback.hook import *"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We want to train quickly, so that means training at a high learning rate. Let's see how we go at 0.06:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def fit(epochs=1):\n",
-    "    learn = Learner(dls, simple_cnn(), loss_func=F.cross_entropy,\n",
-    "                    metrics=accuracy, cbs=ActivationStats(with_hist=True))\n",
-    "    learn.fit(epochs, 0.06)\n",
-    "    return learn"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: left;\">\n",
-       "      <th>epoch</th>\n",
-       "      <th>train_loss</th>\n",
-       "      <th>valid_loss</th>\n",
-       "      <th>accuracy</th>\n",
-       "      <th>time</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <td>0</td>\n",
-       "      <td>2.307071</td>\n",
-       "      <td>2.305865</td>\n",
-       "      <td>0.113500</td>\n",
-       "      <td>00:16</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>"
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "learn = fit()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "This didn't train at all well! Let's find out why.\n",
-    "\n",
-    "One handy feature of the callbacks passed to `Learner` is that they are made available automatically, with the same name as the callback class, except in `camel_case`. So our `ActivationStats` callback can be accessed through `activation_stats`. In fact--I'm sure you remember `learn.recorder`... can you guess how that is implemented? That's right, it's a callback called `Recorder`!\n",
-    "\n",
-    "`ActivationStats` includes some handy utilities for plotting the activations during training. `plot_layer_stats(idx)` plots the mean and standard deviation of the activations of layer number `idx`, along with the percent of activations near zero. Here's the first layer's plot:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 864x216 with 3 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "learn.activation_stats.plot_layer_stats(0)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Generally our model should have a consistent, or at least smooth, mean and standard deviation of layer activations during training. Activations near zero are particularly problematic, because it means we have computation in the model that's doing nothing at all (since multiplying by zero gives zero). When you have some zeros in one layer, they will therefore generally carry over to the next layer... which will then create more zeros. Here's the penultimate layer of our network:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 864x216 with 3 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "learn.activation_stats.plot_layer_stats(-2)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "As expected, the problems get worse towards the end of the network, as the instability and zero activations compound over layers."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Increase batch size"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "One way to make training more stable is to *increase the batch size*. Larger batches have gradients that are more accurate, since they're calculated from more data. On the downside though, a larger batch size means fewer batches per epoch, which means less opportunities for your model to update weights. Let's see if a batch size of 512 helps:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "dls = get_dls(512)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: left;\">\n",
-       "      <th>epoch</th>\n",
-       "      <th>train_loss</th>\n",
-       "      <th>valid_loss</th>\n",
-       "      <th>accuracy</th>\n",
-       "      <th>time</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <td>0</td>\n",
-       "      <td>2.309385</td>\n",
-       "      <td>2.302744</td>\n",
-       "      <td>0.113500</td>\n",
-       "      <td>00:08</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>"
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "learn = fit()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Let's see what the penultimate layer looks like:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 864x216 with 3 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "learn.activation_stats.plot_layer_stats(-2)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Again, we've got most of our activations near zero. Let's see what else we can do to improve training stability."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 1cycle training"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Our initial weights are not well suited to the task we're trying to solve. Therefore, it is dangerous to begin training with a high learning rate: we may very well make the training diverge instantly, as we've seen above. We probably don't want to end training with a high learning rate either, so that we don't skip over a minimum. But we want to train at a high learning rate for the rest of training, because we'll be able to train more quickly. Therefore, we should change the learning rate during training, from low, to high, and then back to low again.\n",
-    "\n",
-    "Leslie Smith (yes, the same guy that invented the learning rate finder!) developed this idea in his article [Super-Convergence: Very Fast Training of Neural Networks Using Large Learning Rates](https://arxiv.org/abs/1708.07120) by designing a schedule for learning rate separated in two phases: one were the learning rate grows from the minimum value to the maximum value (*warm-up*), and then one where it decreases back to the minimum value (*annealing*). Smith called this combination of approaches *1cycle training*.\n",
-    "\n",
-    "1cycle training allows us to use a much higher maximum learning rate than other types of training, which gives two benefits:\n",
-    "\n",
-    "- By training with higher learning rates, we train faster, a phenomenon Leslie N. Smith named *super-convergence*\n",
-    "- By training with higher learning rates, we overfit less because we skip over the sharp local minimas to end-up in a smoother (and therefore more generalizable) part of the loss.\n",
-    "\n",
-    "The second point is an interesting and subtle idea; it is based on the observation that a model that generalises well is one whose loss would not change very much if you change the input by a small amount. If a model trains at a large learning rate for quite a while, and can find a good loss when doing so, it must have found an area that also generalises well, because it is jumping around a lot from batch to batch (that is basically the definition of a high learning rate). The problem is that, as we have discussed, just jumping to a high learning rate is more likely to result in diverging losses, rather than seeing your losses improve. So we don't just jump to a high learning rate. Instead, we start at a low learning rate, where our losses do not diverge, and we allow the optimiser to gradually find smoother and smoother areas of our parameters, by gradually going to higher and higher learning rates.\n",
-    "\n",
-    "Then, once we have found a nice smooth area for our parameters, we then want to find the very best part of that area, which means we have to bring out learning rates down again. This is why 1cycle training has a gradual learning rate warmup, and a gradual learning rate cooldown. Many researchers have found that in practice this approach leads to more accurate models, and trains more quickly. That is why it is the approach that is used by default for `fine_tune` in fastai.\n",
-    "\n",
-    "Later in this book we'll learn all about *momentum* in SGD. Briefly, momentum is a technique where the optimizer takes a step not only in the direction of the gradients, but also continues in the direction of previous steps. Leslie Smith introduced cyclical momentums in [A disciplined approach to neural network hyper-parameters: Part 1](https://arxiv.org/pdf/1803.09820.pdf). It suggests that the momentum varies in the opposite direction of the learning rate: when we are at high learning rate, we use less momentum, and we use more again in the annealing phase.\n",
-    "\n",
-    "We can use 1cycle training in fastai by calling `fit_one_cycle`:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def fit(epochs=1, lr=0.06):\n",
-    "    learn = Learner(dls, simple_cnn(), loss_func=F.cross_entropy,\n",
-    "                    metrics=accuracy, cbs=ActivationStats(with_hist=True))\n",
-    "    learn.fit_one_cycle(epochs, lr)\n",
-    "    return learn"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: left;\">\n",
-       "      <th>epoch</th>\n",
-       "      <th>train_loss</th>\n",
-       "      <th>valid_loss</th>\n",
-       "      <th>accuracy</th>\n",
-       "      <th>time</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <td>0</td>\n",
-       "      <td>0.210838</td>\n",
-       "      <td>0.084827</td>\n",
-       "      <td>0.974300</td>\n",
-       "      <td>00:08</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>"
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "learn = fit()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We're finally making some progress! It's giving us a reasonable accuracy now.\n",
-    "\n",
-    "We can view the learning rate and momentum throughout training by calling `plot_sched` on `learn.recorder`. `learn.recorder` (as the name suggests) records everything that happens during training, including losses, metrics, and hyperparameters such as learning rate and momentum:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 864x288 with 2 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "learn.recorder.plot_sched()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Smith's original 1cycle paper used a linear warm-up and linear annealing. As you see above, we adapted the approach in fastai by combining it with another popular approach: cosine annealing. `fit_one_cycle` provides the following parameters you can adjust:\n",
-    "\n",
-    "- `lr_max`: The highest learning rate that will be used (this can also be a list of learning rates for each layer group, or a python `slice` object containing the first and last layer group learning rates)\n",
-    "- `div`: How much to divide `lr_max` by to get the starting learning rate\n",
-    "- `div_final`:  How much to divide `lr_max` by to get the ending learning rate\n",
-    "- `pct_start`: What % of the batches to use for the warmup\n",
-    "- `moms`: A tuple `(mom1,mom2,mom3)` where mom1 is the initial momentum, mom2 is the minimum momentum, and mom3 is the final momentum.\n",
-    "\n",
-    "Let's take a look at our layer stats again:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 864x216 with 3 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "learn.activation_stats.plot_layer_stats(-2)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "The % of non-zero weights is getting much better, although it's still quite high.\n",
-    "\n",
-    "We can see even more about what's going on in our training using `color_dim`, passing it a layer index:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 720x360 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "learn.activation_stats.color_dim(-2)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "`color_dim` was developed by fast.ai in conjunction with a student, Stefano Giomo. Stefano, who refers to the idea as the *colorful dimension*, has a [detailed explanation](https://forums.fast.ai/t/the-colorful-dimension/42908) of the history and details behind the method. The basic idea is to create a histogram of the activations of a layer, which we would hope would follow a smooth pattern such as the normal distribution shown by Stefano here:"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<img src=\"images/colorful_dist.jpeg\" id=\"colorful_dist\" caption=\"Histogram in 'colorful dimension'\" alt=\"Histogram in 'colorful dimension'\" width=\"800\">"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "To create `color_dim`, we take the histogram shown on the left here, and convert it into just the colored representation shown at the bottom. Then we flip it on its side, as shown on the right. We found that the distribution is clearer if we take the `log` of the histogram values. Then, Stefano describes:\n",
-    "\n",
-    "> : The final plot for each layer is made by stacking the histogram of the activations from each batch along the horizontal axis. So each vertical slice in the visualisation represents the histogram of activations for a single batch. The color intensity corresponds to the height of the histogram, in other words the number of activations in each histogram bin.\n",
-    "\n",
-    "This is Stefano's picture of how this all fits together:"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<img src=\"images/colorful_summ.png\" id=\"colorful_summ\" caption=\"Summary of 'colorful dimension'\" alt=\"Summary of 'colorful dimension'\" width=\"800\">"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "So with that in mind, let's take another look at the result for the penultimate layer:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAADNCAYAAAC8XqoPAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO2dzY5kSZqWzf8iIzIrc6qqK5lWA6JpDaAZaYbZgAQIiQ0bJJbcAkskuBtug9sYwYLesGAxQgIBhdQz9ZcZ4X8sanok/77Hw9/0yO7OMD3Pzk/asWPHjp0Tlu7PeW1xPB6HiIiIyMwsf9cNEBEREflN44RHREREpscJj4iIiEyPEx4RERGZHic8IiIiMj1OeERERGR61o/9479c/ptn8876//u3/6RtW+xPP3/1X79rZY5/9surj7n+xc9PPv/w99+2Ml//w00/5qrXVdu6+baXufm2X44vf/mXvf7N6QG++cWrVubdV32ue6DRAFPizTen7VjAKFk9wEbYtLtdXDwecoBjbk8/b/tpj9X7vm0BdY1F37TclfPe9zJE3W+MMbYvT0/05vveiPs3vTOO0K7t69ONy4dehsbc+ofeLrqW6/enG6kN1F8raMe7L08LHm76jlg/cKzjFdpO13b9LnyslWLLXS9C2+g+qtuOMM6p7w8r6Ix6y2z7jodN32+xz673YV32pe4Kx8CyPAd2d1Sob1q97wc9Lk/3pWcMjR0a+/Qsvf/8tCGre+jXR/9inme5hY1hv27Kfbp9BYVgnNN5E3UsLuG5RudNfVif56v7vt/+BbQhaCvVdeh/Xsd/+Y//4ewTxG94REREZHqc8IiIiMj0OOERERGR6XHCIyIiItNzpYL16bF72T2lzfenUtVh0+d3oR+JHG9vTj4/vIb6SQqkaWYpd7jpRZYgHW6/uG3b1t+dGnIoUYLslQp5tW0krxH7F723X/3fU0Pu+5+CvUZ9CP1Tz4nkXTrvKgWOAeLmGOO4KMItyHckMqOkXg75/vdAUCaRj6TG7y+LoSS2Nul3jDGg/VVEfPW/u6n7/sve2C3ckxWSio9wjXDf2lY6HI0dEnpBLN/8cPoZJXgQWweMnXqeNL7o/luAFN33ywTlKv2OEQrioQhMInbdGSVvuN57kNnrf8+PIHRXSXoM7p/7N5f7jNpA503HXJeXIw70DKCxD2OgSsoovNOLFwCJv7uXp5/xuQntevgM+r9c390dtAHq3wfjifqQ/qY8ht/wiIiIyPQ44REREZHpccIjIiIi0+OER0RERKZnGmmZqLLl/q6f7lM64HhzujdKbjClTGRUkl+3IKNWQZkgSZOSP1ORuQpyKBiG/PDVaWdgejEl6AZTdRLaViTvksxJYuD+chkS65Z7EiRPP5M4TdIvyflVgOa02UzAHJRK+93pAe4/74UoETgRNY8kW2L6L5RrlfdNmDpNwxXGwO7laUOqxDzGGFsQNxMRmMbhgdx/CiwvEi6mmqPE2svta9L5GGNRGoJlSKYO3l2gZ0yakF3PiZ+t2b1M6ef1OYASNrSVkolrmjCJ05iQjcL7aTkSv+mrC3qWUspxhZKcqb+wHa0RfdOuv2eD160moqMwDn34GH7DIyIiItPjhEdERESmxwmPiIiITM+zdHhWb/uq5PTbcPU87r/4uA7P8pvTH/XX96+j/ej36fp76x4Cm26+6dvuf9J/EK2/+ZJTsIMQNfytm1bOLb+30srGFJKYBJ+Rq7EHd4m8hersrGBVbOr7PYU8wu/TtRyVodA8dFmSEDXymWih5NJn9Ns9ulhQbkXhliWYbHV/2SMag/tnV/pnT7/n03/DaFu9luS7hOGNGMxYyu3DQESqvwcPQhkKfSRvr4xrdi4ebeFfQ8GJ9T5KV/rGIL1gFWz0CeGebOGscD3ovDH8FbzGVgauUQ35PFeuhpQS6EbRPV+gMYEru4PDWP82jNG9oTq+xuC+Jv+ueZOhYkPtam0I7+XH8BseERERmR4nPCIiIjI9TnhERERkepzwiIiIyPQ8S2k5pQpgFI72FOpq6fdvYMVrCqcjYbEIWet3vQwJnqv7brnVlZ8XYNKSyJwKvZsqmJEUTcIcyoOnn0lgJEGZQvnWIE9XqA9xBWcMEKyf+/EoGBBl2iJwo3RIIj6FidVrBOOLAvgICpGsQm8ayJaMMZQ0ScwOAjxRnIbVoTGwDoT6FsAHsigG0QVhaHSvJSLtGDDGqL8wpA3qCs4pEY/H4Odau7dCsZyk5TqG6XwoWA9fEgm2ofxP1ygIjKR2sQANL3aUbenK6ATdI7X/6TrSeePfIxCekzbQedNK660ueAY/ht/wiIiIyPQ44REREZHpccIjIiIi0+OER0RERKbnWUrLx7/Zk5ZJCqtyIsqWT+HrX518XBx+0tsAQt5xSdbWqbRFwmpd/X2MMe6/6AUjyRQgQTlZkXh3RyZc30SSYUugpURPcjlhW0uIRUOvb0qSkMcYY1/uFl7ZuO9H1y0RrCl9GVcND1xXGoco+YJwW88JJW8YOyh9lnYc4XxIVkwSaGmc0HhavYf6Iem1yaKwYjQKpOS11gBakKRx7ONK34/XTWXG4PR2bH+Vlmkl7lAEbi8lULvCBOsmqQdjYowzz79grGACdPAyw48HLYcLJfXkWUf3KKU2E8dAsMYV56H69Q/QjpvLgjW9gEDUl1XohYoPjVr2Gx4RERGZHic8IiIiMj1OeERERGR6nPCIiIjI9DxLaXn5zQ9t22Hzedu2KsmcT0mojMBEXShHInAxSCkV+trZKaaphv4XSmdl1KxRAoX64QS2r04PuvkO0otfkQUKm6qkHiZrU5IzyYmtDImCaZJsbRsdj6qnlO7S1ySfYzgyyJbHBQiLReZEwZckb5IygycOyqJwTq2vqe9hHGJb6R6psjZckAUIpElicvqCAF24QxOgoS7o51T+r+OJX7yAdoF8XIXeNAkZXy6o4zCUtekcMaX55vHPY/S/KWOMsQvS25Pn6Llyta9J3qVrhH0RPJ/onqH7b18H4oAxQH0PfUjtry+h4IsXcB0fw294REREZHqc8IiIiMj0OOERERGR6XmWDs/x2+/7Ngjzq8FwD28+7mrpu7/3s9KGXua4ynyH9tsqNDV1TepvpOlvxbgSN/zmXqfJabAe1V+31d9txzjjENDIrecULqRLAYLU/zffnFa4IzeH3InAzcBVf+k3eOif5Hfz1AeCn+XbNYqcpDHYVWs+Qi+D7Q/cA3QDyDVJwxvrNlh5nXZMVypv+4EDQ+GQbZxTCCf5J9B+XLm6toPagM+nvu1jhgVWB4nCQfFZl5zjGD3gD9q6e9m3Ub/WdlAb8HlLAZ7VqYLzppXX0fWhsNSyK65UT14dOVvlmUXXYwkBnsfEB0od2UfwGx4RERGZHic8IiIiMj1OeERERGR6nPCIiIjI9DxLaXm8/aJtQpGyBlWFwlzK7rPTA6DgC0QrIGPYF4ldIKaVMLT1u257vX8JdZFAStRANhTaQI4DsbyKs2lQHK7EXUczBetR34Nsiauelz5LV2HG8LgqNUKKGl0PlHDrWKEy0KwV9Q+Fe5VyJKmnK68vi5x4fAVtIKE0EGep7Xg9gtWtxxhjWWRUklhRyoT7ocquFApH0i+uoF6D4uiawQWn59PVojGJwMHLESiMh7QxRhIr1Q99nYyV9Lyvhl4QuLJ+et7i85xehKhtgDKpyLwvIYzrnhGMgbA0zmugI8rh9Kx4BL/hERERkelxwiMiIiLT44RHREREpscJj4iIiEzPs5SWH37/s7YNkznLNhKcVm/ftm37r7+Oyj0UiRgTPamHg3JLWtE5lKK3L0933n6WpRcf1mQBQjtuL583niMkfzablqRikqJJwKxSG6ULB6ugjzHGDmTaVVkVPkrMPrctWPEaIbm2ppuG0m+S6krbaEV7SsimpNcqNeLq0GGiaiL649ihciQk15ceKC03XFm6ysFbGF8ErnjdGtE30croUV0DROMgUfdsO6pgHa4IT5Z9krSMidZBajO2LUyYpvF0se7B9x+2v0rkJBVjonFWLiL921auG60kn1Lvtyhd/wJ+wyMiIiLT44RHREREpscJj4iIiEyPEx4RERGZnmcpLW8/I0OrbzqWZN/tK4pdzVi87pbhYX1a3+6OTEFKF+7bFodqsfaqMHkXDlll0VTUXeyz/mkyOFwOSnemNNDd3elnlCFDObgJknQ5KK2T5F1KIS71YXIt1J8Ii1WIHiOXj2v/J2nJY7AEuHwH5cp5P7yBpOVQHqwiYipOcx+eVra6D+9vKpaMJ+hXFE9JFg0EaEzRpvTism8izY5x7kUFKFdTwMOEaTxm8l9qksFJGA7GGJ4PJbWHY6yVoXTk4PlEx+OEeihX5Xw4xz29kAMp2kk6NbULXxoI2p+mgBP1WYoCdDj2f43f8IiIiMj0OOERERGR6XHCIyIiItPjhEdERESm51lKy5TqSinBVQQmIYxk5AFJy8dvv2/bljsy68p+NKXERNJj+QzpyLDf7rZvrKmxJPIdbkCmTpODywmQYFjTmM+1IxHYUJAM/FSUNINE7jHOSL5l/KCcSmI51L8uknJNIB6DE1WpXGvDJouIxVRXkjLrNaLqw/86tTFMEja0PxFK93d9v9W7TGRG+Xh/uQwmU8PYaYL75UfHj8UC0ZjGCdYVjv0KpklDuzDpugq38fMQygV9Rn2P5YJEdLzXaLwG9afyLl7vC3WPMcaK7mUAX4SoZULxO0qQp+cJHTN40SK91x7Db3hERERkepzwiIiIyPQ44REREZHpeZYOTw38G4PD/I4PJYCPgr3evIyOSSuoP7z+xWkZCKLDVXmD36draOIYY4wFeDHkJdVd6XdUCBkkrwddluXjn8+ROARp6FWyMj3WRb9P0zUKfuumvkEnCeqvq2UnYXVjnBnD6OzUHbO6aAxXsK00poOxj35I4hGN7kuRy0LXO3Ve6jnRedO9fKQxENyTMaX+NFj02lXV8dqGq563ILowBBAJ/C/sC1rhHIrVex7HSbiyezJ2rl25nK4ZuYN03hSMWtuahF2OccYHSq4R/R2A61aDBuNx8gh+wyMiIiLT44RHREREpscJj4iIiEyPEx4RERGZnmcpLSMkDxaR+bgE2XmTGX+Lf/THbdv6/Wn9GNhEIWqry5IpBQ+SJEYhjItDNaD7fhjuRiIl9mtpA4W2hfJxbxfsR20gsbWGnNF+6YrUJCTXVaopiC6Uj2v/YN8TyX9RUGqEUL73vSCt2l6vdx1eY5wJnwyk6/1tlsCXBJ9haNuRUtr6puUOghnLatOpnE/3Q1t5PQy7RLm57kuBbOFq4Mmq7alkSi9a1H7llw1oQPVNbQVy2o2Md6qK7vl6T9Jfx+xdktY/FHiK1y14ESIdh/gsSl7aCPo+LYdjJ3zWXR1K+wh+wyMiIiLT44RHREREpscJj4iIiEyPEx4RERGZnmcpLb/7qs/TjqtuaB1rIjPIUvc/6UviUmjl8vseUflQV1qPVxsPyqViF8miRWRGmZNSMklgJCGvnie1NUzL3d+VMqnsHEiAKFamqxaTcFv7hwRMWmGZLtL28gXG60bCeyCZYlIxnWPwRFhCWmsqybZzIsH6CStL90J90+qBRH/Yta5KDkJpmkpbBeg67n88IGzC+68UpH6GHfH+C1K6eWVxkLxhTLeXI0IhlpLg68seqUebklzvNDm4rZZOz8Pk2XpmWytD922YrL2qYxOeYZgeTocMytF9Sy+5YHr0E/EbHhEREZkeJzwiIiIyPU54REREZHqc8IiIiMj0PEtpmaTGASmfVXJLU11Xb9/2um56V+1qyjEJbZAiSttqQuhTUoJbim8WJo3TX0pBrfVT2nNsFFbJLRSgua+hXLDfHlKIMbG1jDEUKyk1FqhCHgmSqazdknGTdN4x8J5Z3pNdeeHzOCPvkigdCNbpOKwnisJkIv2eaUeVcGPhHepqIigJxDAOE/mfZOHdHYxpkqkDeZ5S2SluO3lJAOVUFG6za9TK4PXI7u9WDqT+RModo/crCuMvIP0chPrW/ySkh88PvCevlfOpXOkzut4EJkCX9uM5pn/bft2eDysuIiIi8vxwwiMiIiLT44RHREREpud5OjwvYCMEsrWgKjjb3V2f8y1qoOAY44ef9W31Z2Z0hGhKiavr1pXds9+wW7jiGGNUhydcJZlC7ZLAulXqn9B5Vzcj+W19nPEpysrMtF8aiIi/+9emkttAm+h35iDEkMcJbKsqWbgyM60avgf3Y/Uu8MuorRRsWMd5mhSH5WqoHfgP4ROO/IDq1CzB2aIVqdHRq/uG9yR5YvU+3b0CF+uhbcLOZjeqfKTxRGM6cKgw8BSInh/0DAuCFM/t3DzK8BmceIHoT2G4IlRfh04YwknH5DDQy/dkXfX+xwNcrmuE+9E4bOGNH2G24jc8IiIiMj1OeERERGR6nPCIiIjI9DjhERERken55KVlCgHEEKREWgZZ6v3nfc73+rYv03pc9p23n51uI2GuSVxjYOBblXVRXoPzxuDBFu6WyXcHCuAD6awKkVT/4YZktctCIYYApvLd5rIomIZqYfhdLUJ1kTwI1VdJb4nCLVw3qCtZIjoV1xcQPFhl/NV7ClykdgVCLIbVheJp2fcIYXi8ynq2knhra7jidbTSd/hfTZQ5S1upXXtaaRoD+KBcct6pZF+fRfRiBImtRHXUw+cC3acc4FlPPKs/ake68joFvZYwQhTNaTxRv9LfnqCuNLS3jif8mxgGo9YQSQyLTJ8V5w8jIiIiMhdOeERERGR6nPCIiIjI9DjhERERken55KVlglYCRhmrJS33MtvPsjnf7mUvt6+JzyjyhW2tVZGwCrIlJZfu72obehlOCc5W/yaBu0Kr5FL7acXgviNsCzzHujL3GGMs0pRgkOHqCsgoO8eCda08TNamhNtAtkShFE6c5MRlSROmMZfKg3VfTvzu23g16CKp40lCI8Jr1P47uAM5H5LOk5TuKH37TLtS4bm1AVKhE9E4Hk9QLEnSxrGT7EhF6FlHxdIxUPdLX1So8i69aIOJ3NCu4N7C7gqT85tYHqbRI8F51+fJGBiwD2ne8Iz8wBmM3/CIiIjI9DjhERERkelxwiMiIiLT44RHREREpudZSst7kJaX625V7ben8zkSqEhU+/YffNG2be8uS3SUVDwoFRMFrdL+h94wlCEp1bVsIrELRbhQAqyJxktI3kX5ddvLNXmQ/DwSNyMZErZRuSDNdowuemPqKlwPTLgtHYvSXkgkW6bSYSARL6EQiZuREEsCfxrjW+tKzzEd53Ubpp9fTpMeY7Sk3TS1GeXmuh+dNyWFxzJ4LZQlfuPYb7Y2FLkyQRdFYDifBb2MQfduTbBOhXG6bqVt6f1H17ueJ94emNoMddFtVF4wwTGH5ndwTHqehMn2re4nPCM/4DAiIiIizxsnPCIiIjI9TnhERERkepzwiIiIyPQ8S2mZpKoVmFyHKr6BYHi46XUtjr3c+n3ftn9RLKpQaFskScsg7aVJxauH03Io2mHiMCXEklB4+hnTNCFpmdpaBegFiM2JuPnjzkHabyi+oVhXq6LUUkywhk2lrdT0xQ76guqvZTC1GYRxkqnhmA1ISsXkWtq3FEwFxui88Z6B6h9oXyi3vXwfLRPpd2SJsCx+X365IEn6PUdL/KYy4T3DicmnH0lsPpD4HZCkBv9YMK2/XO8o/ffM2K8vjoTXFu+/6n3TOYaeP6Vt17+BT5GDa9tQig8T6pvv/hG+nvEbHhEREZkeJzwiIiIyPU54REREZHo+eYfnu3/2d9u2IwT8LWtw3xhjUcIIm9MzxtiDw/MAK6jff05BgOUzrU4LgYgUkngoIYm00i06CrBa86GuWAv9hSGGaQDY7rLbQCtqJ/Aq8VAOVwK+/ONz/Ps0eVal/niV58SVocOF1639Vk+/59PYCYPVlsUJ27+AJmDA2HVuRupZRfvR6tngA6FbUgMXw5WysR31kBR8Fw6nxC9DfyN0XloAH67qnS2X3u5dCjEM+6KG39FzgVcbh7qAdj8/IayzuSxUFz5vL7cLryP1BfhABwiETcJfsX5o/7VjJ7kneYX7D3vG+A2PiIiITI8THhEREZkeJzwiIiIyPU54REREZHo+eWmZIFl0CfJS3XbYgCwM0vIOVkbHldbrNpLvQqlqWeSu/Q72C1cNbwF/YSgVSrjBNpQCr13hPAiYO19/cN6hVIz1gxhfSTPOarYlSoHhyvEtmIxkYZJYk9WtR79HsF0gixLt+qI4nbW/75i14erVuTHIDeqi/q87Yzhk3y0S46kMNBZlZ5SIiyyKJw7NCsYdPgPovFG8T9oATcAw06RfoS7aLZCWWd7t+6EoXfsnlanD+yh6kYP2O1yunwRrehkD6y/tP4ay9mP4DY+IiIhMjxMeERERmR4nPCIiIjI9TnhERERkej55afnbn/UmLm7v27b1uhtgu12Nu+z10wre+00m6dV9j5CgTO0ijofSVpQaL682PsboicAkiYHAjVYmprPWVeh7mXjV8yoPYspnmKpcN6EQmxp/QCJdk8GICcAlPZXk10DkQ0geDVczX+BAv3xITIgNpMlEFj5LrZ8kbIDumcXD5X1RKoZ7C8XWep54beGgtK3KouE9w3XBtnICeN/iCwFUV/kcjhMUy5M3AugywrhAiThJHE6kYiJM0aZ7t/bFAf5m4SHDlzb6quSp/X85aRkFZXp2X5sgH6Trnxzmg0qLiIiIPEOc8IiIiMj0OOERERGR6XHCIyIiItPzyUvLh03ftiA5GGTUzebUttxBUi7Ja/vbLkLtX0Dbau+RcEZyIvmEpW3LNSSlLrrxR+mpi32RDq9Nrh0jSvalutJU11Z1mBJMgviHCmx/DaauQrlaP54PNTYoRv0cptK2dtD1rgL/mfpRIK1SI0rYUFcaO33pgCmpAE1CbJrw3XaEuqBY60Nqa3o9ykMlln6Dusbo121B5xiK8f2AsA0TdIP60/RwaisJ6FUGx1smFONLX+P1uMleoKgvQuALG0QivA+Q5dPHGsYol7FJL5zASxA4Nuu1xOfhh923fsMjIiIi0+OER0RERKbHCY+IiIhMzyfv8Nx/2betIMxvDX7Otrgs6xsIJ4RgpN2rfkwK36qhSgsI81uRNxQsT7ugqSj9Fr2F32QTtwgcmCMln+FK4uV3WtgPVwJOXJxo6d4z1LZSVbgCeegj1HKYDBj6UokXQ6D7EZx3/Ft35n5cTQvgS4MaYVsdwul+4SrVx7pKPPkhO6gLqI4Q+k3hdWtDDEPt6L6FupKxCc8w3JHqqtebtJVr/wqFuhzeM3QtAwcM+wvDG8t+qfOEz6LLzlZM4ArSOOfx1De1cvjMD55h4/pV3B/Db3hERERkepzwiIiIyPQ44REREZHpccIjIiIi0/PJS8sUXHQD8vFmBULy6nQ+t1t383gLgWO0gjquZFxEqyWIwEsUzC6LiEsIUjyAFH2EVbZb9WEg2xL6lQTrYw2+SmVIogXwZbJlFHJGkDAHUGBkawLJimm7ajkKE6NwxaBdC7jeuHJyKjdTaGGr63oJt+0Wjtdjsy3TVZ5p2+X7CMVNWg06PWYlDcBs8nx4vFTUredJY5NEZipXq0//i52IuVQkvL8HBU3W5lN/wXMZzzvpw/QZWcMCUZwOVyDH8VSKhIIyknQ//kkM2v8Rvp7xGx4RERGZHic8IiIiMj1OeERERGR6nPCIiIjI9Hzy0vLuZTecbmlldNj2UFesRekQ5OAbWJUcJLfj3em+a0iAJvmYROAqN+9SeZckvSLbUaryksRWcmTpmGVfFGLJTEMxN5FYoQ/3tJRxUBcKq5BEjQm3pV/pANRfwerGR4prTVZGH2euUS1D4xclU9hWZfmnBC9Xz5jk17SqdHX0AiadJ8nE6SrVRLIrXcckLZz2e8Kq4Y30GgXjFd1wOu0gcfgp0NivY/GIjQ3F79plwXN6jJGNAepn6sS0DxOx/Nq6UqGe/4ic7gZ9iM+wR/AbHhEREZkeJzwiIiIyPU54REREZHqc8IiIiMj0fPLS8uFlF+ZebHZ926pv265P53P7my443b/Y9GPe9G6hJe0XJZmYUpXXlMwJ7A6nbSUBer/rMvWehLlA1iaZmqa/JHgeigR9PPR2oawGbW1CdeihLje9f1oTQsmRBG6UWGuXwfVmzzE4qSTaeZwRdeuma1Oux2B5sPQjioJXytTUBny5INiXuvAAYigmikOadOsKlEUfad9JQ0o74EUC7K9EWk5E8w+h1pdcxzH6/TEyKR3vGZRRy3MtbVd60HracI1SSba+JID7wWMzSRw+wphepF9dBPcWSuThyx513/QaoUT+EVPZf43f8IiIiMj0OOERERGR6XHCIyIiItPzyTk861/8/OTz4q67ObdrcHhg2/3+9PRqEOEYY6zgN+btLf0YDfsWr4fcojWF5qFbcvm37iWsCH9YXw5/WoHvEioj+IPuosyTyadhz6Nvqv7MU34/joqQz4QrfV8OaTse+v8XyD+hALPkl2f8XZ5cmaANhyQkjCqjY6JDEPonAVe7GRToSSvO065wzDouMOyS6qKuSMIbQ5+prhIfhzdiwF9YsJagQ5KjV+/vcOxEwYN0j4ahktG9lQZUUlW1qRhkSnteDtdbpn5WehvVtqZ1Xds9tN+VIaIfit/wiIiIyPQ44REREZHpccIjIiIi0+OER0RERKbnk5OWv/nT3z/5fHP3QytDgvLNkuTm7cnnLUimmxsILHzRu4XE2bovCcorCPjbQzvWgbS1QTn48pyVAhFJ1j4EdY0xxmJxeVXhtK4qYtN+6NEGQXfBArx/VRe0C/rsUOTBNYydHQTYUV21bUf4v8eCwiGvFClJzKZjJpDgSyTOMtWEoZjAYV+S2wKh+xwoNzdJNmvXEoP0aqFeJpXzl4GNmorrKOwHpCJ+q59WDU8JxkX6IgHWVQM2of70ZY9679JzjZ7B2P66ijtcR3wRJh1PZRu+4ADgM6Xs+zHHIZ1jHFL66+N8UGkRERGRZ4gTHhEREZkeJzwiIiIyPU54REREZHo+PWn5b5+KiC9vH1qZuyIjjzHGLayWviureG/XfXnaG1iVfHvb6xLrHkQAAAiESURBVCJuSrLyDcjUBCUmb4uASe0i2XkP5SokO5PsRRLdHtJlF8XcO+DKw9lK4lXoXS6zVOgkkTkV2lCAxtTbyzIfiuWBBLi/fBnHGGMsg1Rd6hsSp3cwXJO+jhdjD5KDUxGRyq3K2E9XcScWV8rgqUDaEsWhrlggLuVSkXYN0jW29cqk6zglvVBfBvhxv0TMhjbA84PAcZdI0aHQW1nDcxr7HsrV/qHnNHFtW5eUrh+mgNe20n4rGP3JPb+Io6PP4zc8IiIiMj1OeERERGR6nPCIiIjI9DjhERERken55KTldz89FZN+dnvfyrzZvG/bXkDS8sPqVATe7PvpvnzRpegdyMEkgL0o0vItSMskGhO19j0cLxWZqwC2BhkvFUNHIMiR2LyEuFmqf1P6kCXpfsxEzE2lZZQHcd/TtqWJwMkxPzQx9LQdJSkVJFA6x5sbEikvHy9N0U5I+zBKzQ4Srcc4J2BeFnqpX5ehCJyQJHKP0aXV9Hhp/ZX0/kuOSX246u+SXC1Ap+26Vtam+hPxnq9RJu/W/kmvN43phKeMpy4tX/8MTtr/ofea3/CIiIjI9DjhERERkelxwiMiIiLT44RHREREpueTk5a3f+M0RfnNiy4ov1p3kXkFctT2eDqf260hqfgI20DKpCXtX92cCs+UZFoTVs/VVaELEyexFlYghlIbUABDibjIwXBMaimm5da6whRRIumfJ4nMkJCd1E/jqV4TTKu+FvhvDAmAdEQaF/WcWH7N0nKT/k9FRBJgr4W7v0rw16dCJ/ulabad65Jrx+BrWUulT53kObCC5+G14xCfJyTShsJwfbmDXhxJSfa8tl+Tvx9jPO1FiEp+f3+8lzGuHYeP4Tc8IiIiMj1OeERERGR6nPCIiIjI9PxOHZ7ln/5R2/b6J9+ffH774rtW5vPNu7bt/tBP5W5VgsPA16FtFDxIfsirTQ8trDzse6rWkn7hLYdMfZ1FsEI71UW/TyeuyRj9N+Q1eDd5ONZ1Tse1vw3T+VD9seMUtIu8gt8k+zB4kK5bWl9Sf+LwpKuNE9V7Sr2x9N6q5fYQpnmtf0KkxkhtV+p00Ni/1kGiY67Bcbs2pDJpa7xSPZwjBV7WfdfpMxhXDb8cUpreM7Uc5DReXReRtpWea/VZkfTNOZLr/aF/B/yGR0RERKbHCY+IiIhMjxMeERERmR4nPCIiIjI9v1Np+X/8q8/btr/ze39+8vkrkJZfr3oY4Ri3bUsV6w6rbH5HKyATN0XSS+VBYlHkZlrhfAXtouDECrVrA+W2IFiT3PybHDS/Xb33rwDxjc6xlkpWqj9HFSlp5KTBZ13mo3bBeArlxJt1CUl8imhcytG9toWwS64sKBcKq0R1lMk9R5kzqPtjhsKl/2sF5/qjtoM57WsSXfmlgV5Tbf8KJOn0xYtE6E2f5yRFH6IXFdJnxeXxmgaeXk923W7Wl/8mrpaXA1zHyOR8uraP1vlBpUVERESeIU54REREZHqc8IiIiMj0OOERERGR6fmtScurt2/btu2fdCH5D15/ffL5b938qpXZg+KZyLskl92telry3eqmbcNk0SJfvdt3FZhSm3dHSF8ubbtZ9gTl9QKSoqEvmqwdpiofwGpcJqtnkxgaypBdYu37pcnXta6PmfZM9VVpPd0vPeY6TIBuZWIpN7tuSVtTQfJasZ/2qzJnmix7rVieyMhjnGvr5WOm+yX3DPGhgudj7SJQ4C7Ce3I+5+qq0HWktGdiRWOlbEteXBgjWyX++tdZroek7rT/K9eu7P4U6jE/xmTFb3hERERkepzwiIiIyPQ44REREZHpccIjIiIi0/Nbk5b/+7//g7btn//8l23bH738Xyefv1x3sfkv9q/atu2qK4U1mXiz6FIxpRe/WfckZxK77g+Xu2936O3aHfsxd0VIZiEWJDTQyarI/AAJyg+L3nZM6wQZvPYZpUKnIiUJyZeOd67+SL57Qhr2tZBYXq8bCaUkAu8COT9NgKY+XF+Z6noE4Z3Ou0Lp3tQuSp2+VoAmYTUZr9eOOdo33S8pl95r175IQC24ti6CrgclZCc8RcSvz4anpFAndaVC/bVjJ71GlaesGHBtGxJxPe3DR9vzQaVFREREniFOeERERGR6nPCIiIjI9HwUh+f//Lt/evL523/8rpX513/4Z23bv3jz39q2n67+8uTzA8R9rcBbuT90P2dTPJiXyx4yuFlQOBOs4Axhgd/t+wrtlQM4FxRQWKHgwU3osrTjgbu0PvS63kO7DuAb1baRw5O4IGOM8VAcJ/otl/qQrlEtlzgk545JXPtbelLXGsbhYdnPu/bXGODswH9j6HrU++NcudrXT3FZHor3Rg4anSMFYCZtSP2Na30mIlqJOxybieNGPCUMtPIU36het4/hYTxWF5H2Re1req5dC43za1lEK7HnVE9zE65m/lF9SKiqXt+PcTy/4REREZHpccIjIiIi0+OER0RERKbHCY+IiIhMz6PS8n/6n100JpbjP5fPsGourPS9PXY56leH09C/P9/1lcs3iy70ElVufrnqgYJvll2wvl1u27YHkJa/Xrw5+UwhfSQ7k9xXRTGSll+E22r9JKF9B/1KkiYJpDelvrtV7684DC0QuFNpMgnlS1djJ6rEmO5H7a911T4d48z5wNDf1VW9QTSn86YxhvJuaWsqYGLg4pXibHJtX5DIHoQ+jsHBj10sT1ehh2DRYyLn03Oz13XtSuLXsgpd0aRdqax9reT7lPNerS5f32tl8FSoT8o95aUBYj2uk7OvFb+prfQsTaTxDz1vv+ERERGR6XHCIyIiItPjhEdERESmxwmPiIiITM/iePy4qY0iIiIinxp+wyMiIiLT44RHREREpscJj4iIiEyPEx4RERGZHic8IiIiMj1OeERERGR6/j8jStwSQ8E4SwAAAABJRU5ErkJggg==\n",
-      "text/plain": [
-       "<Figure size 720x360 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "learn.activation_stats.color_dim(-2)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "This shows a classic picture of \"bad training\". We start with nearly all activations at zero--that's what we see at the far left, with nearly all the left hand side dark blue; the bright yellow at the bottom are the near-zero activations. Then over the first few batches we see the number of non-zero activations exponentially increasing. But it goes too far, and collapses! We see the dark blue return, and the bottom becomes bright yellow again. It almost looks like training restarts from scratch. Then we see the activations increase again, and then it collapses again. After repeating a few times, eventually we see a spread of activations throughout the range.\n",
-    "\n",
-    "It's much better if training can be smooth from the start. The cycles of exponential increase and then collapse that we see above tend to result in a lot of near-zero activations, resulting in slow training, and poor final results."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Batch normalization"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "To fix this, we need to both fix the initial large percentage of near-zero activations, and then try to maintain a good distribution of activations throughout training. In the abstract, they describe just the problem that we've seen:\n",
-    "\n",
-    "Sergey Ioffe and Christian Szegedy showed a solution to this problem in the 2015 paper [Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift](https://arxiv.org/abs/1502.03167). \n",
-    "\n",
-    "> : \"Training Deep Neural Networks is complicated by the fact that the distribution of each layer's inputs changes during training, as the parameters of the previous layers change. This slows down the training by requiring lower learning rates and careful parameter initialization... We refer to this phenomenon as internal covariate shift, and address the problem by normalizing layer inputs.\"\n",
-    "\n",
-    "Their solution, they say is:\n",
-    "\n",
-    "> : \"...making normalization a part of the model architecture and performing the normalization for each training mini-batch. Batch Normalization allows us to use much higher learning rates and be less careful about initialization.\"\n",
-    "\n",
-    "The paper caused great excitement as soon as it was released, because they showed this chart, which clearly demonstrated that batch normalization could train a model that was even more accurate than the current state of the art (the *inception* architecture), around 5x faster:"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<img alt=\"Impact of batch normalization\" width=\"553\" caption=\"Impact of batch normalization\" id=\"batchnorm\" src=\"images/att_00046.png\">"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "The way batch normalization (often just called *batchnorm*) works is that it takes an average of the mean and standard deviations of the activations of a layer, and uses those to normalize the activations. However, this can cause problems because the network might really want some activations to be really high in order to make accurate predictions, they also add two learnable parameters (meaning they will be updated in our SGD step), usually called `gamma` and `beta`; after normalizing the activations to get some new activation vector `y`, a batchnorm layer returns `gamma*y + beta`.\n",
-    "\n",
-    "That why our activations can have any mean or variance, which is independent from the mean and std of the results of the previous layer. Those statistics are learned separately, making training easier on our model. The behavior is different during training and validation: during training, we use the mean and standard deviation of the batch to normalize the data. During validation, we instead use a running mean of the statistics calculated during training.\n",
-    "\n",
-    "Let's add a batchnorm layer to `conv`:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def conv(ni, nf, ks=3, act=True):\n",
-    "    layers = [nn.Conv2d(ni, nf, stride=2, kernel_size=ks, padding=ks//2)]\n",
-    "    layers.append(nn.BatchNorm2d(nf))\n",
-    "    if act: layers.append(nn.ReLU())\n",
-    "    return nn.Sequential(*layers)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "...and fit our model:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: left;\">\n",
-       "      <th>epoch</th>\n",
-       "      <th>train_loss</th>\n",
-       "      <th>valid_loss</th>\n",
-       "      <th>accuracy</th>\n",
-       "      <th>time</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <td>0</td>\n",
-       "      <td>0.130036</td>\n",
-       "      <td>0.055021</td>\n",
-       "      <td>0.986400</td>\n",
-       "      <td>00:10</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>"
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "learn = fit()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "That's a great result! Let's take a look at `color_dim`:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 720x360 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "learn.activation_stats.color_dim(-4)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "This is just what we hope to see: a smooth development of activations, with no \"crashes\". Batchnorm has really delivered on its promise here! In fact, batchnorm has been so successful that we see it (or something very similar) today in nearly all modern neural networks.\n",
-    "\n",
-    "An interesting observation about models containing batch normalisation layers is that they tend to generalise better than models that don't contain them. Although we haven't as yet seen a rigourous analysis of what's going on here, most researchers believe that the reason for this is that batch normalisation add some extra randomness to the training process. Each mini batch will have a somewhat different mean and standard deviation to each other mini batch. Therefore, the activations will be normalised by different values each time. In order for the model to make accurate predictions, it will have to learn to become insensitive to these variations. In general, adding additional randomisation to the training process often helps.\n",
-    "\n",
-    "Since things are going so well, let's train for a few more epochs and see how it goes. In fact, let's even *increase* the learning rate, since the abstract of the batchnorm paper claimed we should be able to \"train at much higher learning rates\":"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: left;\">\n",
-       "      <th>epoch</th>\n",
-       "      <th>train_loss</th>\n",
-       "      <th>valid_loss</th>\n",
-       "      <th>accuracy</th>\n",
-       "      <th>time</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <td>0</td>\n",
-       "      <td>0.191731</td>\n",
-       "      <td>0.121738</td>\n",
-       "      <td>0.960900</td>\n",
-       "      <td>00:11</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>1</td>\n",
-       "      <td>0.083739</td>\n",
-       "      <td>0.055808</td>\n",
-       "      <td>0.981800</td>\n",
-       "      <td>00:10</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>2</td>\n",
-       "      <td>0.053161</td>\n",
-       "      <td>0.044485</td>\n",
-       "      <td>0.987100</td>\n",
-       "      <td>00:10</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>3</td>\n",
-       "      <td>0.034433</td>\n",
-       "      <td>0.030233</td>\n",
-       "      <td>0.990200</td>\n",
-       "      <td>00:10</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>4</td>\n",
-       "      <td>0.017646</td>\n",
-       "      <td>0.025407</td>\n",
-       "      <td>0.991200</td>\n",
-       "      <td>00:10</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>"
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "learn = fit(5, lr=0.1)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: left;\">\n",
-       "      <th>epoch</th>\n",
-       "      <th>train_loss</th>\n",
-       "      <th>valid_loss</th>\n",
-       "      <th>accuracy</th>\n",
-       "      <th>time</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <td>0</td>\n",
-       "      <td>0.183244</td>\n",
-       "      <td>0.084025</td>\n",
-       "      <td>0.975800</td>\n",
-       "      <td>00:13</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>1</td>\n",
-       "      <td>0.080774</td>\n",
-       "      <td>0.067060</td>\n",
-       "      <td>0.978800</td>\n",
-       "      <td>00:12</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>2</td>\n",
-       "      <td>0.050215</td>\n",
-       "      <td>0.062595</td>\n",
-       "      <td>0.981300</td>\n",
-       "      <td>00:12</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>3</td>\n",
-       "      <td>0.030020</td>\n",
-       "      <td>0.030315</td>\n",
-       "      <td>0.990700</td>\n",
-       "      <td>00:12</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>4</td>\n",
-       "      <td>0.015131</td>\n",
-       "      <td>0.025148</td>\n",
-       "      <td>0.992100</td>\n",
-       "      <td>00:12</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>"
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "learn = fit(5, lr=0.1)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "At this point, I think it's fair to say we know how to recognize digits! It's time to move on to something harder..."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Questionnaire"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "1. What method can we use to see that data in DataLoaders?\n",
-    "1. Why do we double the number of filters after each stride 2 conv?\n",
-    "1. Why do we use a larger kernel in the first conv with MNIST (with `simple_cnn`)?\n",
-    "1. What information does `ActivationStats` save for each layer?\n",
-    "1. How can we access a learner's callback after training?\n",
-    "1. What are the three statistics plotted by `plot_layer_stats`? What does the x-axis represent?\n",
-    "1. Why are activations near zero problematic?\n",
-    "1. What are the upsides and downsides of training with a larger batch size?\n",
-    "1. Why should we avoid using a high learning rate at the start of training?\n",
-    "1. What is 1cycle training?\n",
-    "1. What are the benefits of training with a high learning rate?\n",
-    "1. Why do we want to use a low learning rate at the end of training?\n",
-    "1. What is cyclical momentum?\n",
-    "1. What callback tracks hyperparameter values during training (along with other information)?\n",
-    "1. What does one column of pixels in the `color_dim` plot represent?\n",
-    "1. What does \"bad training\" look like in `color_dim`? Why?\n",
-    "1. What trainable parameters does a batch normalization layer contain?\n",
-    "1. What statistics are used to normalize in batch normalization during training? How about during validation?\n",
-    "1. Why do models with batch normalization layers generalize better?"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Further research"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "1. There are other normalization layers available in PyTorch. Try them out and see what works best. Learn about why other normalization layers have been developed, and how they differ from batch normalization.\n",
-    "1. Try moving the activation function after the batch normalization layer in `conv`. Does it make a difference? See what you can find out about what order is recommended, and why.\n",
-    "1. Batch normalization isn't defined for a batch size of one, since the standard deviation isn't defined for a single item. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "jupytext": {
-   "split_at_heading": true
-  },
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/15_resnet.ipynb b/14_resnet.ipynb
similarity index 98%
rename from 15_resnet.ipynb
rename to 14_resnet.ipynb
index 1614936..b5217a0 100644
--- a/15_resnet.ipynb
+++ b/14_resnet.ipynb
@@ -26,6 +26,15 @@
     "# Resnets"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In this chapter, we will build on top of the CNNs introduced in the previous chapter and explain to you the ResNet (for residual network) architecture. It was introduced in 2015 in [this article](https://arxiv.org/abs/1512.03385) and is by far the most used model architecture nowadays. More recent developments in models almost always use the same trick of residual connections, and most of the time, they are just a tweak of the original ResNet.\n",
+    "\n",
+    "We will frist show you the basic ResNet as it was first designed, then explain to you what modern tweaks to it make it more performamt. But first, we will need a problem a little bit more difficult that the MNIST dataset, since we are already close to 100% accuracy with a regular CNN on it."
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -37,7 +46,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "It's going to be tough to judge any improvement we do to our models when we are already at an accuracy that is as high as we saw on MNIST in the previous chapter, so we will tackle a tougher problem by going back to Imagenette. We'll stick with small images to keep things reasonably fast.\n",
+    "It's going to be tough to judge any improvement we do to our models when we are already at an accuracy that is as high as we saw on MNIST in the previous chapter, so we will tackle a tougher image classification problem by going back to Imagenette. We'll stick with small images to keep things reasonably fast.\n",
     "\n",
     "Let's grab the data--we'll use the already-resized 160px version to make things faster still, and will random crop to 128px:"
    ]
@@ -303,7 +312,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "That's a pretty good start, considering we have to pick the correct one of ten categories, and we're training from scratch for just 5 epochs!"
+    "That's a pretty good start, considering we have to pick the correct one of ten categories, and we're training from scratch for just 5 epochs! But we can do way better than this using a deeper model. However, just stacking new layers won't really improve our results (you can try and see for yourself!). To work around this problem, ResNets introduce the idea of skip connections. Let's have a look at what it is exactly."
    ]
   },
   {
@@ -317,7 +326,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "We now have all the pieces needed to build the models we have been using in each computer vision task since the beginning of this book: ResNets. We introduce the main idea behind them and show how it improves accuracy Imagenette compared to our previous model, before building a version with all the recent tweaks."
+    "We now have all the pieces needed to build the models we have been using in each computer vision task since the beginning of this book: ResNets. We'll introduce the main idea behind them and show how it improves accuracy Imagenette compared to our previous model, before building a version with all the recent tweaks."
    ]
   },
   {
@@ -335,7 +344,7 @@
     "\n",
     "> : Unexpectedly, such degradation is not caused by overfitting, and adding more layers to a suitably deep model leads to higher training error, as [previously reported] and thoroughly verified by our experiments.\n",
     "\n",
-    "This is the graph they showed, with training error on the left, and test on the right:"
+    "They showed the graph in <<resnet_depth>>, with training error on the left, and test on the right."
    ]
   },
   {
@@ -361,7 +370,7 @@
     "\n",
     "What has that gained us, then? The key thing is that those 36 extra layers, as they stand, are an *identity mapping*, but they have *parameters*, which means they are *trainable*. So, we can start with our best 20 layer model, add these 36 extra layers which initially do nothing at all, and then *fine tune the whole 56 layer model*. If those extra 36 layers can be useful, then they can learn parameters to do so!\n",
     "\n",
-    "The ResNet paper actually proposed a variant of this, which is to instead \"skip over\" every 2nd convolution, so effectively we get `x+conv2(conv1(x))`. Or In diagram form (from the paper):"
+    "The ResNet paper actually proposed a variant of this, which is to instead \"skip over\" every 2nd convolution, so effectively we get `x+conv2(conv1(x))`. This is shown by the diagram in <<resnet_block>> (from the paper)."
    ]
   },
   {
@@ -659,7 +668,7 @@
     "\n",
     "The authors of the ResNet paper went on to win the 2015 ImageNet challenge. At the time, this was by far the most important annual event in computer vision. We have already seen another ImageNet winner: the 2013 winners, Zeiler and Fergus. It is interesting to note that in both cases the starting point for the breakthroughs were experimental observations. Observations about what layers actually learn, in the case of Zeiler and Fergus, and observations about which kind of networks can be trained, in the case of the ResNet authors. This ability to design and analyse thoughtful experiments, or even just to see an unexpected result say \"hmmm, that's interesting\" — and then, most importantly, to figure out what on earth is going on, with great tenacity, is at the heart of many scientific discoveries. Deep learning is not like pure mathematics. It is a heavily experimental field, so it's important to be strong practitioner, not just a theoretician.\n",
     "\n",
-    "Since the ResNet was introduced, there's been many papers studying it and applying it to many domains. One of the most interesting, published in 2018, is [Visualizing the Loss Landscape of Neural Nets](https://arxiv.org/abs/1712.09913). It shows that using skip connections help smoothen the loss function, which makes training easier as it avoids us falling into a very sharp area. Here's a stunning picture from the paper, showing the bumpy terrain that SGD has to navigate to optimize a regular CNN (left) versus the smooth surface of a ResNet (right):"
+    "Since the ResNet was introduced, there's been many papers studying it and applying it to many domains. One of the most interesting, published in 2018, is [Visualizing the Loss Landscape of Neural Nets](https://arxiv.org/abs/1712.09913). It shows that using skip connections help smoothen the loss function, which makes training easier as it avoids us falling into a very sharp area. <<resnet_surface>> shows a stunning picture from the paper, showing the bumpy terrain that SGD has to navigate to optimize a regular CNN (left) versus the smooth surface of a ResNet (right)."
    ]
   },
   {
@@ -669,6 +678,13 @@
     "<img alt=\"Impact of ResNet on loss landscape\" width=\"600\" caption=\"Impact of ResNet on loss landscape\" id=\"resnet_surface\" src=\"images/att_00044.png\">"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This first model is already good, but further research has discovered more tricks we can apply to make it better."
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -910,7 +926,9 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Even although we have more channels (and our model is therefore even more accurate), our training is just as fast as before, thanks to our optimized stem."
+    "Even although we have more channels (and our model is therefore even more accurate), our training is just as fast as before, thanks to our optimized stem.\n",
+    "\n",
+    "To make our model deeper without taking too much compute or memory, the ResNet paper introduced anotehr kind of blocks for ResNets with a depth of 50 or more, using something called a bottleneck. "
    ]
   },
   {
@@ -924,7 +942,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Things are a tiny bit more complicated for deeper models like `resnet50` as they don't use the same resnet blocks: instead of stacking two convolutions with a kernel size of 3, they use three different convolutions: two 1x1 (at the beginning and the end) and one 3x3, as shown in the right of this image from the ResNet paper (using an example of 64 channel output, comparing to the regular ResBlock on the left):"
+    "Instead of stacking two convolutions with a kernel size of 3, *bottleneck layers* use three different convolutions: two 1x1 (at the beginning and the end) and one 3x3, as shown in the right of <<resnet_compare>> the ResNet paper (using an example of 64 channel output, comparing to the regular ResBlock on the left)."
    ]
   },
   {
@@ -938,7 +956,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Why? 1x1 convolutions are much faster, so even if this seems to be a more complex design, this block executes faster than the first resnet block we saw. This then lets us use more filters: as we see on the illustration, the number of filters in and out is 4 times higher (256) and the 1 by 1 convs are here to diminish then restore the number of channels (hence the name bottleneck). The overall impact is that we can use more filters in the same amount of time.\n",
+    "Why is that useful? 1x1 convolutions are much faster, so even if this seems to be a more complex design, this block executes faster than the first resnet block we saw. This then lets us use more filters: as we see on the illustration, the number of filters in and out is 4 times higher (256) and the 1 by 1 convs are here to diminish then restore the number of channels (hence the name bottleneck). The overall impact is that we can use more filters in the same amount of time.\n",
     "\n",
     "Let's try replacing our ResBlock with this bottleneck design:"
    ]
@@ -1174,6 +1192,13 @@
     "The bottleneck design we've shown here is only used in ResNet50, 101, and 152 in all official models we've seen. ResNet18 and 34 use the non-bottleneck design seen in the previous section. However, we've noticed that the bottleneck layer generally works better even for the shallower networks. This just goes to show that the little details in papers tend to stick around for years, even if they're actually not quite the best design! Questioning assumptions and \"stuff everyone knows\" is always a good idea, because this is still a new field, and there's lots of details that aren't always done well."
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "TK add conclusion"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -1243,31 +1268,6 @@
    "display_name": "Python 3",
    "language": "python",
    "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.7.5"
-  },
-  "toc": {
-   "base_numbering": 1,
-   "nav_menu": {},
-   "number_sections": false,
-   "sideBar": true,
-   "skip_h1_title": true,
-   "title_cell": "Table of Contents",
-   "title_sidebar": "Contents",
-   "toc_cell": false,
-   "toc_position": {},
-   "toc_section_display": true,
-   "toc_window_display": false
   }
  },
  "nbformat": 4,
diff --git a/16_arch_details.ipynb b/15_arch_details.ipynb
similarity index 89%
rename from 16_arch_details.ipynb
rename to 15_arch_details.ipynb
index 5a6dc7d..6a96b5b 100644
--- a/16_arch_details.ipynb
+++ b/15_arch_details.ipynb
@@ -28,7 +28,11 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "We are now in the exciting position that we can fully understand the entire architectures that we have been using for our state-of-the-art models for computer vision, natural language processing, and tabular analysis. In this chapter, we're going to fill in all the missing details on how fastai's application models work."
+    "We are now in the exciting position that we can fully understand the entire architectures that we have been using for our state-of-the-art models for computer vision, natural language processing, and tabular analysis. In this chapter, we're going to fill in all the missing details on how fastai's application models work and show you how to build the models they use.\n",
+    "\n",
+    "We will also go back to the custom data preprocessing pipeline we saw in <<chapter_midlevel_data>> for Siamese networks and show you how you can use the components in the fastai library to build custom pretrained models for new tasks.\n",
+    "\n",
+    "We will go voer each application in turn, starting with computer vision."
    ]
   },
   {
@@ -38,6 +42,13 @@
     "## Computer vision"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In computer vision, we used the functions `cnn_learner` and `unet_learner` to build our models, depending on the task. Let's see how they start from a pretrained ResNet to build the `Learner` objects we have used in part 1 and 2 of this book."
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -162,6 +173,13 @@
     "> note: One parameter to create_head that is worth looking at is bn_final. Setting this to true will cause a batchnorm layer to be added as your final layer. This can be useful in helping your model to more easily ensure that it is scaled appropriately for your output activations. We haven't seen this approach published anywhere, as yet, but we have found that it works well in practice, wherever we have used it."
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's now have a look at what `unet_learner` did in the segmentation problem we showed in <<chapter_intro>>."
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -181,7 +199,7 @@
     "\n",
     "We will (naturally) do this with a neural network! So we need some kind of layer which can increase the grid size in a CNN. One very simple approach to this is to replace every pixel in the 7x7 grid with four pixels in a 2x2 square. Each of those four pixels would have the same value — this is known as nearest neighbour interpolation. PyTorch provides a layer which does this for us, so we could create a head which contains stride one convolutional layers (along with batchnorm and ReLU as usual) interspersed with 2x2 nearest neighbour interpolation layers. In fact, you could try this now! See if you can create a custom head designed like this, and see if it can complete the CamVid segmentation task. You should find that you get some reasonable results, although it won't be as good as our <<chapter_intro>> results.\n",
     "\n",
-    "Another approach is to replace the nearest neighbour and convolution combination with a *transposed convolution* otherwise known as a *stride half convolution*. This is identical to a regular convolution, but first zero padding is inserted between every pixel in the input. This is easiest to see with a picture — here's a diagram from the excellent convolutional arithmetic paper we have seen before, showing a 3x3 transposed convolution applied to a 3x3 image:"
+    "Another approach is to replace the nearest neighbour and convolution combination with a *transposed convolution* otherwise known as a *stride half convolution*. This is identical to a regular convolution, but first zero padding is inserted between every pixel in the input. This is easiest to see with a picture — <<transp_conv>> shows a diagram from the excellent convolutional arithmetic paper we have seen before, showing a 3x3 transposed convolution applied to a 3x3 image."
    ]
   },
   {
@@ -199,7 +217,7 @@
     "\n",
     "Neither of these approaches, however, works really well. The problem is that our 7x7 grid simply doesn't have enough information to create a 224x224 pixel output. It's asking an awful lot of the activations of each of those grid cells to have enough information to fully regenerate every pixel in the output. The solution to this problem is to use skip connections, like in a resnet, but skipping from the activations in the body of the resnet all the way over to the activations of the transposed convolution on the opposite side of the architecture. This is known as a U-Net, and it was developed in the 2015 paper [U-Net: Convolutional Networks for Biomedical Image Segmentation](https://arxiv.org/abs/1505.04597). Although the paper focussed on medical applications, the U-Net has revolutionized all kinds of generation vision models.\n",
     "\n",
-    "The U-Net paper shows the architecture like this:"
+    "<<unet>> shows the U-Net architecture (form the paper). "
    ]
   },
   {
@@ -218,6 +236,13 @@
     "With this architecture, the input to the transposed convolutions is not just the lower resolution grid in the preceding layer, but also the higher resolution grid in the resnet head. This allows the U-Net to use all of the information of the original image, as it is needed. One challenge with U-Nets is that the exact architecture depends on the image size. fastai has a unique `DynamicUnet` class which auto-generates an architecture of the right size based on the data provided."
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now that we've seen how to create complete state of the art computer vision models, let's move on to NLP."
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -229,9 +254,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Now that we've seen how to create complete state of the art computer vision models, let's move on to NLP.\n",
-    "\n",
-    "Converting an AWD-LSTM language model into a transfer learning classifier follows a very similar process to what we saw for `cnn_learner` in the first section of this chapter. We do not need a \"meta\" dictionary in this case, because we do not have such a variety of architectures to support in the body. All we need to do is to select the stacked RNN for the encoder in the language model, which is a single PyTorch module. This encoder will provide an activation for every word of the input, because a language model needs to output a prediction for every next word.\n",
+    "Converting an AWD-LSTM language model into a transfer learning classifier as we have done in <<chapter_nlp>> follows a very similar process to what we saw for `cnn_learner` in the first section of this chapter. We do not need a \"meta\" dictionary in this case, because we do not have such a variety of architectures to support in the body. All we need to do is to select the stacked RNN for the encoder in the language model, which is a single PyTorch module. This encoder will provide an activation for every word of the input, because a language model needs to output a prediction for every next word.\n",
     "\n",
     "To create a classifier from this we use an approach described in the ULMFiT paper as \"BPTT for Text Classification (BPT3C)\". The paper describes this:"
    ]
@@ -240,7 +263,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "> In order to make fine-tuning a classifier for large documents feasible, we propose BPTT for Text Classification (BPT3C): We divide the document into fixed-length batches of size `b`. At the beginning of each batch, the model is initialized with the final state of the previous batch; we keep track of the hidden states for mean and max-pooling; gradients are back-propagated to the batches whose hidden states contributed to the final prediction. In practice, we use variable length backpropagation sequences."
+    "> : In order to make fine-tuning a classifier for large documents feasible, we propose BPTT for Text Classification (BPT3C): We divide the document into fixed-length batches of size `b`. At the beginning of each batch, the model is initialized with the final state of the previous batch; we keep track of the hidden states for mean and max-pooling; gradients are back-propagated to the batches whose hidden states contributed to the final prediction. In practice, we use variable length backpropagation sequences."
    ]
   },
   {
@@ -256,6 +279,13 @@
     "This is done automatically behind the scenes by the fastai library when creating our `DataLoaders`."
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The last application where we used fastai's model we haven't shown you yet is tabular."
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -336,7 +366,9 @@
     "\n",
     "```\n",
     "\n",
-    "Finally, this is passed through the linear layers (each of which includes batchnorm, if `use_bn` is True, and dropout, if `ps` is set to some value or list of values)."
+    "Finally, this is passed through the linear layers (each of which includes batchnorm, if `use_bn` is True, and dropout, if `ps` is set to some value or list of values).\n",
+    "\n",
+    "Congratulations! Now, you know every single piece of the architectures used in the fastai library!"
    ]
   },
   {
@@ -354,7 +386,7 @@
     "\n",
     "Now that we have investigated all of the pieces of a model and the data that is passed into it, we can consider what this means for practical deep learning. If you have unlimited data, unlimited memory, and unlimited time, then the advice is easy: train a huge model on all of your data for a really long time. The reason that deep learning is not straightforward is because your data, memory, and time is limited. If you are running out of memory or time, then the solution is to train a smaller model. If you are not able to train for long enough to overfit, then you are not taking advantage of the capacity of your model.\n",
     "\n",
-    "So step one is to get to the point that you can overfit. Then, the question is how to reduce that overfitting. Here is how we recommend prioritising the steps from there:"
+    "So step one is to get to the point that you can overfit. Then, the question is how to reduce that overfitting. <<reduce_overfit>> shows how we recommend prioritising the steps from there."
    ]
   },
   {
diff --git a/17_accel_sgd.ipynb b/16_accel_sgd.ipynb
similarity index 86%
rename from 17_accel_sgd.ipynb
rename to 16_accel_sgd.ipynb
index d0c1e09..7320cb3 100644
--- a/17_accel_sgd.ipynb
+++ b/16_accel_sgd.ipynb
@@ -23,22 +23,24 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Variants of SGD"
+    "# The training process"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Now that you know all about how the architectures are put together, it's time to start exploring the training process.\n",
+    "Since we now know how to create state-of-the-art architectures for computer vision, natural image processing, tabular analysis, and collaborative filtering, and we know how to train them quickly, we're done, right? Not quite yet. We still have to explorea little bit more the training process.\n",
     "\n",
-    "We explained earlier the basis of Stochastic Gradient Descent: pass a minibatch in the model, compare it to our target with the loss function then compute the gradients of this loss function with regards to each weight before updating the weights with the formula:\n",
+    "We explained in <<chapter_mnist_basics>> the basis of Stochastic Gradient Descent: pass a minibatch in the model, compare it to our target with the loss function then compute the gradients of this loss function with regards to each weight before updating the weights with the formula:\n",
     "\n",
     "```python\n",
     "new_weight = weight - lr * weight.grad\n",
     "```\n",
     "\n",
-    "We implemented this from scratch in a training loop, and also saw that Pytorch provides a simple `nn.SGD` class that does this calculation for each parameter for us. Let's now build some faster optimizers, using a flexible foundation."
+    "We implemented this from scratch in a training loop, and also saw that Pytorch provides a simple `nn.SGD` class that does this calculation for each parameter for us. In this chapter, we will build some faster optimizers, using a flexible foundation. But that's not all what we might want to change in the training process. For any tweak of the training loop, we will need a way to add some code to the basis of SGD. The fastai library has a system of callbacks to do this, and we will teach you all about it.\n",
+    "\n",
+    "Firs things first, let's start with standard SGD to get a baseline, then we will introduce most commonly used optimizers."
    ]
   },
   {
@@ -429,7 +431,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "It's working! So that's how we create SGD from scratch in fastai."
+    "It's working! So that's how we create SGD from scratch in fastai. Now let's see see what this momentum is exactly."
    ]
   },
   {
@@ -456,7 +458,7 @@
     "\n",
     "Note that we are writing `weight.avg` to highlight the fact we need to store thoe moving averages for each parameter of the model (and they all their own independent moving averages).\n",
     "\n",
-    "Here is an example of noisy data for a single parameter, with the momentum curve plotted in red, and the gradients of the parameter plotted in blue. The gradients increase, and then decrease, and the momentum does a good job of following the general trend, without getting too influenced by noise:"
+    "<<img_momentum>> shows an example of noisy data for a single parameter, with the momentum curve plotted in red, and the gradients of the parameter plotted in blue. The gradients increase, and then decrease, and the momentum does a good job of following the general trend, without getting too influenced by noise."
    ]
   },
   {
@@ -480,6 +482,10 @@
     }
    ],
    "source": [
+    "#hide_input\n",
+    "#id img_mommentum\n",
+    "#caption An example of momentum\n",
+    "#alt Graph showing an example of momentum\n",
     "x = np.linspace(-4, 4, 100)\n",
     "y = 1 - (x/3) ** 2\n",
     "x1 = x + np.random.randn(100) * 0.1\n",
@@ -499,7 +505,7 @@
    "source": [
     "It works particularly well if the loss function has narrow canyons we need to navigate: vanilla SGD would send us from one side to the other while SGD with momentum will average those to roll down inside. The parameter `beta` determines the strength of that momentum we are using: with a small beta we stay closer to the actual gradient values whereas with a high beta, we will mostly go in the direction of the average of the gradients and it will take a while before any change in the gradients makes that trend move.\n",
     "\n",
-    "With a large beta, we might miss that the gradients have changed directions and roll over a small local minima which is a desired side-effect: intuitively, when we show a new picture/text/data to our model, it will look like something in the training set but won't be exactly like it. That means it will correspond to a point in the loss function that is closest to the minimum we ended up with at the end of training, but not exactly *at* that minimum. We then would rather end up training in a wide minimum, where nearby points have approximately the same loss (or if you prefer, a point where the loss is as flat as possible). Here's how the above chart varies as we change beta:"
+    "With a large beta, we might miss that the gradients have changed directions and roll over a small local minima which is a desired side-effect: intuitively, when we show a new picture/text/data to our model, it will look like something in the training set but won't be exactly like it. That means it will correspond to a point in the loss function that is closest to the minimum we ended up with at the end of training, but not exactly *at* that minimum. We then would rather end up training in a wide minimum, where nearby points have approximately the same loss (or if you prefer, a point where the loss is as flat as possible). <<img_betas>> shows how the chart in <<img_momentum>> varies as we change beta."
    ]
   },
   {
@@ -523,6 +529,10 @@
     }
    ],
    "source": [
+    "#hide_input\n",
+    "#id img_betas\n",
+    "#caption Momentum with different beta values\n",
+    "#alt Graph showing how the beta value imfluence momentum\n",
     "x = np.linspace(-4, 4, 100)\n",
     "y = 1 - (x/3) ** 2\n",
     "x1 = x + np.random.randn(100) * 0.1\n",
@@ -852,7 +862,9 @@
     "\n",
     "In fastai, Adam is the default optimizer we use since it allows faster training, but we found that `beta2=0.99` is better suited for the type of schedule we are using. `beta1` is the momentum parameter, which we specify with the argument `moms` in our call to `fit_one_cycle`. As for `eps`, fastai uses a default of 1e-5. `eps` is not just useful for numerical stability. A higher `eps` limits the maximum value of the adjusted learning rate. To take an extreme example, if `eps` is 1, then the adjusted learning will never be higher than the base learning rate. \n",
     "\n",
-    "Rather than show all the code for this in the book, we'll let you look at the optimizer notebook in fastai's GitHub repository--you'll see all the code we've seen so far, along with Adam and other optimizers, and lots of examples and tests."
+    "Rather than show all the code for this in the book, we'll let you look at the optimizer notebook in fastai's GitHub repository--you'll see all the code we've seen so far, along with Adam and other optimizers, and lots of examples and tests.\n",
+    "\n",
+    "One thing that changes when we go from SGD to Adam is the way we apply weight decay, and it can have important consequences."
    ]
   },
   {
@@ -889,7 +901,319 @@
     "\n",
     "Most libraries use the first formulation, but it was pointed out in [Decoupled Weight Regularization](https://arxiv.org/pdf/1711.05101.pdf) by Ilya Loshchilov and Frank Hutter, second one is the only correct approach with the Adam optimizer or momentum, which is why fastai makes it its default.\n",
     "\n",
-    "Now you know everything that is hidden behind the line `learn.fit_one_cycle`!"
+    "Now you know everything that is hidden behind the line `learn.fit_one_cycle`!\n",
+    "\n",
+    "OPtimizers are only one part of the training process. When you need to change the training loop with fastai, you can't directly change the code inside the library. Instead, we have designed a system of callbacks to let you write any tweak in independent blocks you can then mix and match. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Callbacks"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Sometimes you need to change how things work a little bit. In fact, we have already seen examples of this: mixup, FP16 training, resetting the model after each epoch for training RNNs, and so forth. How do we go about making these kinds of tweaks to the training process?\n",
+    "\n",
+    "We've seen the basic training loop, which, with the help of the `Optimizer` class, looks like this for a single epoch:\n",
+    "\n",
+    "```python\n",
+    "for xb,yb in dl:\n",
+    "    loss = loss_func(model(xb), yb)\n",
+    "    loss.backward()\n",
+    "    opt.step()\n",
+    "    opt.zero_grad()\n",
+    "```\n",
+    "\n",
+    "<<basic_loop>> shows how to picture that."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<img alt=\"Basic training loop\" width=\"300\" caption=\"Basic training loop\" id=\"basic_loop\" src=\"images/att_00048.png\">"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The usual way for deep learning practitioners to customise the training loop is to make a copy of an existing training loop, and then insert their code necessary for their particular changes into it. This is how nearly all code that you find online will look. But it has some very serious problems.\n",
+    "\n",
+    "It's not very likely that some particular tweaked training loop is going to meet your particular needs. There are hundreds of changes that can be made to a training loop, which means there are billions and billions of possible permutations. You can't just copy one tweak from a training loop here, another from a training loop there, and expect them all to work together. Each will be based on different assumptions about the environment that it's working in, use different naming conventions, and expect the data to be in different formats.\n",
+    "\n",
+    "We need a way to allow users to insert their own code at any part of the training loop, but in a consistent and well-defined way. Computer scientists have already come up with an answer to this question: the callback. A callback is a piece of code that you write, and inject into another piece of code at some predefined point. In fact, callbacks have been used with deep learning training loops for years. The problem is that only a small subset of places that may require code injection have been available in previous libraries, and, more importantly, callbacks were not able to do all the things they needed to do.\n",
+    "\n",
+    "In order to be just as flexible as manually copying and pasting a training loop and directly inserting code into it, a callback must be able to read every possible piece of information available in the training loop, modify all of it as needed, and fully control when a batch, epoch, or even all the whole training loop should be terminated. fastai is the first library to provide all of this functionality. It modifies the training loop so it looks like <<cb_loop>>."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<img alt=\"Training loop with callbacks\" width=\"550\" caption=\"Training loop with callbacks\" id=\"cb_loop\" src=\"images/att_00049.png\">"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The real test of whether this works has been borne out over the last couple of years — it has turned out that every single new paper implemented, or use a request fulfilled, for modifying the training loop has successfully been achieved entirely by using the fastai callback system. The training loop itself has not required modifications. <<some_cbs>> shows just a few of the callbacks that have been added."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<img alt=\"Some fastai callbacks\" width=\"500\" caption=\"Some fastai callbacks\" id=\"some_cbs\" src=\"images/att_00050.png\">"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The reason that this is important for all of us is that it means that whatever idea we have in our head, we can implement it. We need never dig into the source code of PyTorch or fastai and act together some one-off system to try out our ideas. And when we do implement our own callbacks to develop our own ideas, we know that they will work together with all of the other functionality provided by fastai – so we will get progress bars, mixed precision training, hyperparameter annealing, and so forth.\n",
+    "\n",
+    "Another advantage is that it makes it easy to gradually remove or add functionality and perform ablation studies. You just need to adjust the list of callbacks you pass along to your fit function."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As an example, here is the fastai source code that is run for each batch of the training loop:\n",
+    "\n",
+    "```python\n",
+    "try:\n",
+    "    self._split(b);                                  self('begin_batch')\n",
+    "    self.pred = self.model(*self.xb);                self('after_pred')\n",
+    "    self.loss = self.loss_func(self.pred, *self.yb); self('after_loss')\n",
+    "    if not self.training: return\n",
+    "    self.loss.backward();                            self('after_backward')\n",
+    "    self.opt.step();                                 self('after_step')\n",
+    "    self.opt.zero_grad()\n",
+    "except CancelBatchException:                         self('after_cancel_batch')\n",
+    "finally:                                             self('after_batch')\n",
+    "```\n",
+    "\n",
+    "The calls of the form `self('...')` are where the callbacks are called. As you see, after every step a callback is called. The callback will receive the entire state of training, and can also modify it. For instance, as you see above, the input data and target labels are in `self.xb` and `self.yb` respectively. A callback can modify these to modify the data the training loop sees. It can also modify `self.loss`, or even modify the gradients.\n",
+    "\n",
+    "Let's see how this work in practice by writing a `Callback`."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Creating a callback"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "When you want to write your own callback, the full list of available events is:\n",
+    "\n",
+    "- `begin_fit`:: called before doing anything, ideal for initial setup.\n",
+    "- `begin_epoch`:: called at the beginning of each epoch, useful for any behavior you need to reset at each epoch.\n",
+    "- `begin_train`:: called at the beginning of the training part of an epoch.\n",
+    "- `begin_batch`:: called at the beginning of each batch, just after drawing said batch. It can be used to do any setup necessary for the batch (like hyper-parameter scheduling) or to change the input/target before it goes in the model (change of the input with techniques like mixup for instance).\n",
+    "- `after_pred`:: called after computing the output of the model on the batch. It can be used to change that output before it's fed to the loss.\n",
+    "- `after_loss`:: called after the loss has been computed, but before the backward pass. It can be used to add any penalty to the loss (AR or TAR in RNN training for instance).\n",
+    "- `after_backward`:: called after the backward pass, but before the update of the parameters. It can be used to do any change to the gradients before said update (gradient clipping for instance).\n",
+    "- `after_step`:: called after the step and before the gradients are zeroed.\n",
+    "- `after_batch`:: called at the end of a batch, for any clean-up before the next one.\n",
+    "- `after_train`:: called at the end of the training phase of an epoch.\n",
+    "- `begin_validate`:: called at the beginning of the validation phase of an epoch, useful for any setup needed specifically for validation.\n",
+    "- `after_validate`:: called at the end of the validation part of an epoch.\n",
+    "- `after_epoch`:: called at the end of an epoch, for any clean-up before the next one.\n",
+    "- `after_fit`:: called at the end of training, for final clean-up.\n",
+    "\n",
+    "This list is available as attributes of the special variable `event`; so just type `event.` and hit `Tab` in your notebook to see a list of all the options"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's take a look at an example. Do you recall how in <<chapter_nlp_dive>> we needed to ensure that our special `reset` method was called at the start of training and validation for each epoch? We used the `ModelReseter` callback provided by fastai to do this for us. But how did `ModelReseter` do that exactly? Here's the full actual source code to that class:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class ModelReseter(Callback):\n",
+    "    def begin_train(self):    self.model.reset()\n",
+    "    def begin_validate(self): self.model.reset()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Yes, that's actually it! It just does what we said in the paragraph above: after completing training and epoch or validation for an epoch, call a method named `reset`.\n",
+    "\n",
+    "Callbacks are often \"short and sweet\" like this one. In fact, let's look at one more. Here's the fastai source for the callback that add RNN regularization (*AR* and *TAR*):"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class RNNRegularizer(Callback):\n",
+    "    def __init__(self, alpha=0., beta=0.): self.alpha,self.beta = alpha,beta\n",
+    "\n",
+    "    def after_pred(self):\n",
+    "        self.raw_out,self.out = self.pred[1],self.pred[2]\n",
+    "        self.learn.pred = self.pred[0]\n",
+    "\n",
+    "    def after_loss(self):\n",
+    "        if not self.training: return\n",
+    "        if self.alpha != 0.:\n",
+    "            self.learn.loss += self.alpha * self.out[-1].float().pow(2).mean()\n",
+    "        if self.beta != 0.:\n",
+    "            h = self.raw_out[-1]\n",
+    "            if len(h)>1:\n",
+    "                self.learn.loss += self.beta * (h[:,1:] - h[:,:-1]\n",
+    "                                               ).float().pow(2).mean()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "> stop: Go back to where we discussed TAR and AR regularization, and compare to the code here. Made sure you understand what it's doing, and why."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In both of these examples, notice how we can access attributes of the training loop by directly checking `self.model` or `self.pred`. That's because a `Callback` will always try to get an attribute it doesn't have inside the `Learner` associated to it. This is a shortcut for `self.learn.model` or `self.learn.pred`. Note that this shortcut works for reading attributes, but not for writing them, which is why when `RNNRegularizer` changes the loss or the predictions, you see `self.learn.loss = ` or `self.learn.pred = `. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "When writing a callback, the following attributes of `Learner` are available:\n",
+    "\n",
+    "- `model`: the model used for training/validation\n",
+    "- `data`: the underlying `DataLoaders`\n",
+    "- `loss_func`: the loss function used\n",
+    "- `opt`: the optimizer used to udpate the model parameters\n",
+    "- `opt_func`: the function used to create the optimizer\n",
+    "- `cbs`: the list containing all `Callback`s\n",
+    "- `dl`: current `DataLoader` used for iteration\n",
+    "- `x`/`xb`: last input drawn from `self.dl` (potentially modified by callbacks). `xb` is always a tuple (potentially with one element) and `x` is detuplified. You can only assign to `xb`.\n",
+    "- `y`/`yb`: last target drawn from `self.dl` (potentially modified by callbacks). `yb` is always a tuple (potentially with one element) and `y` is detuplified. You can only assign to `yb`.\n",
+    "- `pred`: last predictions from `self.model` (potentially modified by callbacks)\n",
+    "- `loss`: last computed loss (potentially modified by callbacks)\n",
+    "- `n_epoch`: the number of epochs in this training\n",
+    "- `n_iter`: the number of iterations in the current `self.dl`\n",
+    "- `epoch`: the current epoch index (from 0 to `n_epoch-1`)\n",
+    "- `iter`: the current iteration index in `self.dl` (from 0 to `n_iter-1`)\n",
+    "\n",
+    "The following attributes are added by `TrainEvalCallback` and should be available unless you went out of your way to remove that callback:\n",
+    "\n",
+    "- `train_iter`: the number of training iterations done since the beginning of this training\n",
+    "- `pct_train`: from 0. to 1., the percentage of training iterations completed\n",
+    "- `training`:  flag to indicate if we're in training mode or not\n",
+    "\n",
+    "The following attribute is added by `Recorder` and should be available unless you went out of your way to remove that callback:\n",
+    "\n",
+    "- `smooth_loss`: an exponentially-averaged version of the training loss"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Callbacks can also interrupt any part of the training loop by using a system of exceptions."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Callback ordering and exceptions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Sometimes, callbacks need to be able to tell fastai to skip over a batch, or an epoch, or stop training altogether. For instance, consider `TerminateOnNaNCallback`. This handy callback will automatically stop training any time the loss becomes infinite or `NaN` (*not a number*). Here's the fastai source for this callback:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class TerminateOnNaNCallback(Callback):\n",
+    "    run_before=Recorder\n",
+    "    def after_batch(self):\n",
+    "        if torch.isinf(self.loss) or torch.isnan(self.loss):\n",
+    "            raise CancelFitException"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The way it tells the training loop to interrupt training at this point is to `raise CancelFitException`. The training loop catches this exception and does not run any further training or validation. The callback control flow exceptions available are:\n",
+    "\n",
+    "- `CancelFitException`:: Skip the rest of this batch and go to `after_batch\n",
+    "- `CancelEpochException`:: Skip the rest of the training part of the epoch and go to `after_train\n",
+    "- `CancelTrainException`:: Skip the rest of the validation part of the epoch and go to `after_validate\n",
+    "- `CancelValidException`:: Skip the rest of this epoch and go to `after_epoch\n",
+    "- `CancelBatchException`:: Interrupts training and go to `after_fit"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You can detect one of those exceptions occurred and add code that executes right after with the following events:\n",
+    "\n",
+    "- `after_cancel_batch`:: reached immediately after a `CancelBatchException` before proceeding to `after_batch`\n",
+    "- `after_cancel_train`:: reached immediately after a `CancelTrainException` before proceeding to `after_epoch`\n",
+    "- `after_cancel_valid`:: reached immediately after a `CancelValidException` before proceeding to `after_epoch`\n",
+    "- `after_cancel_epoch`:: reached immediately after a `CancelEpochException` before proceeding to `after_epoch`\n",
+    "- `after_cancel_fit`:: reached immediately after a `CancelFitException` before proceeding to `after_fit`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Sometimes, callbacks need to be called in a particular order. In the case of `TerminateOnNaNCallback`, it's important that `Recorder` runs its `after_batch` after this callback, to avoid registering an NaN loss. You can specify `run_before` (this callback must run before ...) or `run_after` (this callback must run after ...) in your callback to ensure the ordering that you need."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now that we have seen how to tweak the training loop of fastai to do anything we need, let's take a step back and dig a little bit deeper in the foundations of that training loop."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "TK Write a conclusion"
    ]
   },
   {
@@ -920,7 +1244,16 @@
     "1. Calculate the value of `unbias_avg` and `w.avg` for a few batches of dummy values.\n",
     "1. What's the impact of having a high eps in Adam?\n",
     "1. Read through the optimizer notebook in fastai's repo, and execute it.\n",
-    "1. In what situations do dynamic learning rate methods like Adam change the behaviour of weight decay?"
+    "1. In what situations do dynamic learning rate methods like Adam change the behaviour of weight decay?\n",
+    "1. What are the four steps of a training loop?\n",
+    "1. Why is the use of callbacks better than writing a new training loop for each tweak you want to add?\n",
+    "1. What are the necessary points in the design of the fastai's callback system that make it as flexible as copying and pasting bits of code?\n",
+    "1. How can you get the list of events available to you when writing a callback?\n",
+    "1. Write the `ModelResetter` callback (without peeking).\n",
+    "1. How can you access the necessary attributes of the training loop inside a callback? When can you use or not use the shortcut that goes with it?\n",
+    "1. How can a callback influence the control flow of the training loop.\n",
+    "1. Write the `TerminateOnNaN` callback (without peeking if possible).\n",
+    "1. How do you make sure your callback runs after or before another callback?"
    ]
   },
   {
@@ -934,7 +1267,28 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "1. Look up the \"rectified Adam\" paper and implement it using the general optimizer framework, and try it out. Search for other recent optimizers that work well in practice, and pick one to implement."
+    "1. Look up the \"rectified Adam\" paper and implement it using the general optimizer framework, and try it out. Search for other recent optimizers that work well in practice, and pick one to implement.\n",
+    "1. Look at the mixed precision callback with the documentation. Try to understand what each event and line of code does.\n",
+    "1. Implement your own version of ther learning rate finder from scratch. Compare it with fastai's version.\n",
+    "1. Look at the source code of the callbacks that ship with fastai. See if you can find one that's similar to what you're looking to do, to get some inspiration."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Foundations of Deep Learning: Wrap up"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Congratulations, you have made it to the end of the \"foundations of deep learning\" section. You now understand how all of fastai's applications and most important architectures are built, and the recommended ways to train them, and have all the information you need to build these from scratch. Whilst you probably won't need to create your own training loop, or batchnorm layer, for instance, knowing what is going on behind the scenes is very helpful for debugging, profiling, and deploying your solutions.\n",
+    "\n",
+    "Since you understand all of the foundations of fastai's applications now, be sure to spend some time digging through fastai's source notebooks, and running and experimenting with parts of them, since you can and see exactly how everything in fastai is developed.\n",
+    "\n",
+    "In the next section, we will be looking even further under the covers, to see how the actual forward and backward passes of a neural network are done, and we will see what tools are at our disposal to get better performance. We will then finish up with a project that brings together everything we have learned throughout the book, which we will use to build a method for interpreting convolutional neural networks."
    ]
   },
   {
diff --git a/19_foundations.ipynb b/17_foundations.ipynb
similarity index 96%
rename from 19_foundations.ipynb
rename to 17_foundations.ipynb
index 2695de5..fe2d1d8 100644
--- a/19_foundations.ipynb
+++ b/17_foundations.ipynb
@@ -39,7 +39,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## A neural net from scratch"
+    "## A neural net layer from scratch"
    ]
   },
   {
@@ -470,14 +470,14 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Broadcasting"
+    "### Broadcasting"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "As we discussed in <<chapter_mnist_basics>>, broadcasting is a term introduced by the numpy library that describes how tensor of different ranks are treated during arithmetic operations. For instance, it's obvious there is no way to add a 3 by 3 matrix with a 4 by 5 matrix, but what if we want to add one scalar (which can be represented as a 1 by 1 tensor) with a matrix? Or a vector of size 3 with a 3 by 4 matrix? In both cases, we can find a way to make sense of what the operation could be.\n",
+    "As we discussed in <<chapter_mnist_basics>>, broadcasting is a term introduced by the [numpy library](https://docs.scipy.org/doc/) that describes how tensor of different ranks are treated during arithmetic operations. For instance, it's obvious there is no way to add a 3 by 3 matrix with a 4 by 5 matrix, but what if we want to add one scalar (which can be represented as a 1 by 1 tensor) with a matrix? Or a vector of size 3 with a 3 by 4 matrix? In both cases, we can find a way to make sense of what the operation could be.\n",
     "\n",
     "Broadcasting gives specific rules to codify when shapes are compatible when trying to do an element-wise operation, and how the tensor of the smaller shape is expanded to match the tensor of the bigger shape. It's essential to master those rules if you want to be able to write code that executes quickly. In this section, we'll expand our previous treatment of broadcasting to understand these rules."
    ]
@@ -486,14 +486,14 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Broadcasting with a scalar"
+    "#### Broadcasting with a scalar"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "This is the easiest broadcating: when we have a tensor `a` and a scalar, we just imagine a tensor of the same shape as `a` filled with that scalar and perform the operation."
+    "Broadcasting with a scalar is the easiest broadcating: when we have a tensor `a` and a scalar, we just imagine a tensor of the same shape as `a` filled with that scalar and perform the operation."
    ]
   },
   {
@@ -553,7 +553,14 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Broadcasting a vector to a matrix"
+    "Now you could have different means for each row of the matrix, in which case you would need to broadcast a vector to a matrix."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Broadcasting a vector to a matrix"
    ]
   },
   {
@@ -1027,14 +1034,14 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "We're now 3,700 times faster than our first implementation!"
+    "We're now 3,700 times faster than our first implementation! Now let's discuss the exact rules of broadcasting."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Broadcasting Rules"
+    "#### Broadcasting Rules"
    ]
   },
   {
@@ -1077,7 +1084,14 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Einstein summation"
+    "Another useful thing for tensor manipulations is the use of Einstein summations."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Einstein summation"
    ]
   },
   {
@@ -1157,6 +1171,13 @@
     "As we see, not only is it practical, but it's *very* fast. `einsum` is often the fastest way to do custom operations in PyTorch, without diving into C++ and CUDA. (But it's generally not as fast as carefully optimized CUDA code, as you see in the matrix multiplication example)."
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now that we know how to implement a matrix multiplication from scratch, we are ready to build our neural net, specifically its forward and backward passes, just using matrix multiplications."
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -1168,7 +1189,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Now that we have defined `matmul` from scratch, we are ready to define our first neural net. As we saw in <<chapter_mnist_basics>>, to train it, we will need to compute all the gradients of a given a loss with respect to its parameters, which is known as the *backward pass*. The *forward pass* is computing the output of the model on a given input, which is just based on the matrix products we saw. As we define our first neural net, we will also delve in the problem of properly initializing the weights, which is crucial to make training start properly."
+    "As we saw in <<chapter_mnist_basics>>, to train it, we will need to compute all the gradients of a given a loss with respect to its parameters, which is known as the *backward pass*. The *forward pass* is computing the output of the model on a given input, which is just based on the matrix products we saw. As we define our first neural net, we will also delve in the problem of properly initializing the weights, which is crucial to make training start properly."
    ]
   },
   {
@@ -1734,6 +1755,13 @@
     "loss = mse(out, y)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "That is all for the forward pass, let now look at the gradients."
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -1932,6 +1960,13 @@
     "And now we can access to the gradients of our model parameters in `w1.g`, `b1.g`, `w2.g`, `b2.g`."
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We have sucessfuly defined our model, now let's make it a bit more like a PyTorch module."
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -2194,6 +2229,7 @@
     "Then the structure used to build a more complex model that takes advantage of those functions is a `torch.nn.Module`. This is the base structure for all models and all the neural nets you have seen up until now where from that class. It mostly helps to register all the trainable parameters, which as we've seen can be used in the training loop.\n",
     "\n",
     "To implement a `nn.Module` you just need to\n",
+    "\n",
     "- Make sure the superclass `__init__` is called first when you initiliaze it,\n",
     "- Define any parameter of the model as attributes with `nn.Parameter`,\n",
     "- Define a `forward` function that returns the output of your model.\n",
@@ -2314,6 +2350,8 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
+    "TK tweak this and make it a real conclusion\n",
+    "\n",
     "- A neural net is basically a bunch of matrix multiplications with non-linearities in-between.\n",
     "- Python is slow so to write fast code we have to vectorize it and take advantage of element-wise arithmetic or broadcasting.\n",
     "- Two tensors are broadcastable if the dimensions starting from the end and going backward match (they are the same or one of them is 1). To make tensors broadcastable, we may need to add dimensions of size 1 with `unsqueeze` or a `None` index.\n",
diff --git a/20_CAM.ipynb b/18_CAM.ipynb
similarity index 99%
rename from 20_CAM.ipynb
rename to 18_CAM.ipynb
index 82957c9..949dc12 100644
--- a/20_CAM.ipynb
+++ b/18_CAM.ipynb
@@ -30,7 +30,9 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Now that we know how to build up pretty much anything from scratch, let's use that knowledge to create entirely new (and very useful!) functionality: the *class activation map*. In the process, we'll learn about one handy feature of PyTorch we haven't seen before, the *hook*, and we'll apply many of the concepts classes we've learned in the rest of the book. If you want to really test out your understanding of the material in this book, after you've finished this chapter, try putting the book aside, and recreate the ideas here yourself from scratch (no peaking!)"
+    "Now that we know how to build up pretty much anything from scratch, let's use that knowledge to create entirely new (and very useful!) functionality: the *class activation map*. It gives a us an hindsight of why a CNN made the predictions it did.\n",
+    "\n",
+    "In the process, we'll learn about one handy feature of PyTorch we haven't seen before, the *hook*, and we'll apply many of the concepts classes we've learned in the rest of the book. If you want to really test out your understanding of the material in this book, after you've finished this chapter, try putting the book aside, and recreate the ideas here yourself from scratch (no peaking!)"
    ]
   },
   {
@@ -44,7 +46,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Class Activation Mapping (or CAM) was introduced by Zhou et al. in [Learning Deep Features for Discriminative Localization](https://arxiv.org/abs/1512.04150). It uses the output of the last convolutional layer (just before our average pooling) together with the predictions to give us some heatmap visulaization of why the model made its decision.\n",
+    "Class Activation Mapping (or CAM) was introduced by Zhou et al. in [Learning Deep Features for Discriminative Localization](https://arxiv.org/abs/1512.04150). It uses the output of the last convolutional layer (just before our average pooling) together with the predictions to give us some heatmap visulaization of why the model made its decision. This is a useful tool for intepretation.\n",
     "\n",
     "More precisely, at each position of our final convolutional layer we have has many filters as the last linear layer. We can then compute the dot product of those activations by the final weights to have, for each location on our feature map, the score of the feature that was used to make a decision.\n",
     "\n",
@@ -422,6 +424,13 @@
     "fastai provides this `Hook` class for you, as well as some other handy classes to make working with hooks easier."
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This method is useful but only works for the last layer. Gradient CAM is a variant that addreses this problem."
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -580,6 +589,13 @@
     "              interpolation='bilinear', cmap='magma');"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "TK Write conclusion"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
diff --git a/18_callbacks.ipynb b/18_callbacks.ipynb
deleted file mode 100644
index 28e06ed..0000000
--- a/18_callbacks.ipynb
+++ /dev/null
@@ -1,419 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#hide\n",
-    "from utils import *"
-   ]
-  },
-  {
-   "cell_type": "raw",
-   "metadata": {},
-   "source": [
-    "[[chapter_callbacks]]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Callbacks"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Introduction to callbacks"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Since we now know how to create state-of-the-art architectures for computer vision, natural image processing, tabular analysis, and collaborative filtering, and we know how to train them quickly with accelerated optimisers, and we know how to regularise them effectively, we're done, right?\n",
-    "\n",
-    "Well… Yes, sort of. But other things come up. Sometimes you need to change how things work a little bit. In fact, we have already seen examples of this: mixup, FP16 training, resetting the model after each epoch for training RNNs, and so forth. How do we go about making these kinds of tweaks to the training process?\n",
-    "\n",
-    "We've seen the basic training loop, which, with the help of the `Optimizer` class, looks like this for a single epoch:\n",
-    "\n",
-    "```python\n",
-    "for xb,yb in dl:\n",
-    "    loss = loss_func(model(xb), yb)\n",
-    "    loss.backward()\n",
-    "    opt.step()\n",
-    "    opt.zero_grad()\n",
-    "```\n",
-    "\n",
-    "Here's one way to picture that:"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<img alt=\"Basic training loop\" width=\"300\" caption=\"Basic training loop\" id=\"basic_loop\" src=\"images/att_00048.png\">"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "The usual way for deep learning practitioners to customise the training loop is to make a copy of an existing training loop, and then insert their code necessary for their particular changes into it. This is how nearly all code that you find online will look. But it has some very serious problems.\n",
-    "\n",
-    "It's not very likely that some particular tweaked training loop is going to meet your particular needs. There are hundreds of changes that can be made to a training loop, which means there are billions and billions of possible permutations. You can't just copy one tweak from a training loop here, another from a training loop there, and expect them all to work together. Each will be based on different assumptions about the environment that it's working in, use different naming conventions, and expect the data to be in different formats.\n",
-    "\n",
-    "We need a way to allow users to insert their own code at any part of the training loop, but in a consistent and well-defined way. Computer scientists have already come up with an answer to this question: the callback. A callback is a piece of code that you write, and inject into another piece of code at some predefined point. In fact, callbacks have been used with deep learning training loops for years. The problem is that only a small subset of places that may require code injection have been available in previous libraries, and, more importantly, callbacks were not able to do all the things they needed to do.\n",
-    "\n",
-    "In order to be just as flexible as manually copying and pasting a training loop and directly inserting code into it, a callback must be able to read every possible piece of information available in the training loop, modify all of it as needed, and fully control when a batch, epoch, or even all the whole training loop should be terminated. fastai is the first library to provide all of this functionality. It modifies the training loop so it looks like this:"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<img alt=\"Training loop with callbacks\" width=\"550\" caption=\"Training loop with callbacks\" id=\"cb_loop\" src=\"images/att_00049.png\">"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "The real test of whether this works has been borne out over the last couple of years — it has turned out that every single new paper implemented, or use a request fulfilled, for modifying the training loop has successfully been achieved entirely by using the fastai callback system. The training loop itself has not required modifications. Here are just a few of the callbacks that have been added:"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<img alt=\"Some fastai callbacks\" width=\"500\" caption=\"Some fastai callbacks\" id=\"some_cbs\" src=\"images/att_00050.png\">"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "The reason that this is important for all of us is that it means that whatever idea we have in our head, we can implement it. We need never dig into the source code of PyTorch or fastai and act together some one-off system to try out our ideas. And when we do implement our own callbacks to develop our own ideas, we know that they will work together with all of the other functionality provided by fastai – so we will get progress bars, mixed precision training, hyperparameter annealing, and so forth.\n",
-    "\n",
-    "Another advantage is that it makes it easy to gradually remove or add functionality and perform ablation studies. You just need to adjust the list of callbacks you pass along to your fit function."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "As an example, here is the fastai source code that is run for each batch of the training loop:\n",
-    "\n",
-    "```python\n",
-    "try:\n",
-    "    self._split(b);                                  self('begin_batch')\n",
-    "    self.pred = self.model(*self.xb);                self('after_pred')\n",
-    "    self.loss = self.loss_func(self.pred, *self.yb); self('after_loss')\n",
-    "    if not self.training: return\n",
-    "    self.loss.backward();                            self('after_backward')\n",
-    "    self.opt.step();                                 self('after_step')\n",
-    "    self.opt.zero_grad()\n",
-    "except CancelBatchException:                         self('after_cancel_batch')\n",
-    "finally:                                             self('after_batch')\n",
-    "```\n",
-    "\n",
-    "The calls of the form `self('...')` are where the callbacks are called. As you see, after every step a callback is called. The callback will receive the entire state of training, and can also modify it. For instance, as you see above, the input data and target labels are in `self.xb` and `self.yb` respectively. A callback can modify these to modify the data the training loop sees. It can also modify `self.loss`, or even modify the gradients."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Creating a callback"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "The full list of available callback events is:\n",
-    "\n",
-    "- `begin_fit`: called before doing anything, ideal for initial setup.\n",
-    "- `begin_epoch`: called at the beginning of each epoch, useful for any behavior you need to reset at each epoch.\n",
-    "- `begin_train`: called at the beginning of the training part of an epoch.\n",
-    "- `begin_batch`: called at the beginning of each batch, just after drawing said batch. It can be used to do any setup necessary for the batch (like hyper-parameter scheduling) or to change the input/target before it goes in the model (change of the input with techniques like mixup for instance).\n",
-    "- `after_pred`: called after computing the output of the model on the batch. It can be used to change that output before it's fed to the loss.\n",
-    "- `after_loss`: called after the loss has been computed, but before the backward pass. It can be used to add any penalty to the loss (AR or TAR in RNN training for instance).\n",
-    "- `after_backward`: called after the backward pass, but before the update of the parameters. It can be used to do any change to the gradients before said update (gradient clipping for instance).\n",
-    "- `after_step`: called after the step and before the gradients are zeroed.\n",
-    "- `after_batch`: called at the end of a batch, for any clean-up before the next one.\n",
-    "- `after_train`: called at the end of the training phase of an epoch.\n",
-    "- `begin_validate`: called at the beginning of the validation phase of an epoch, useful for any setup needed specifically for validation.\n",
-    "- `after_validate`: called at the end of the validation part of an epoch.\n",
-    "- `after_epoch`: called at the end of an epoch, for any clean-up before the next one.\n",
-    "- `after_fit`: called at the end of training, for final clean-up.\n",
-    "\n",
-    "This list is available as attributes of the special variable `event`; so just type `event.` and hit `Tab` in your notebook to see a list of all the options"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Let's take a look at an example. Do you recall how in <<chapter_nlp_dive>> we needed to ensure that our special `reset` method was called at the start of training and validation for each epoch? We used the `ModelReseter` callback provided by fastai to do this for us. But how did `ModelReseter` do that exactly? Here's the full actual source code to that class:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class ModelReseter(Callback):\n",
-    "    def begin_train(self):    self.model.reset()\n",
-    "    def begin_validate(self): self.model.reset()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Yes, that's actually it! It just does what we said in the paragraph above: after completing training and epoch or validation for an epoch, call a method named `reset`.\n",
-    "\n",
-    "Callbacks are often \"short and sweet\" like this one. In fact, let's look at one more. Here's the fastai source for the callback that add RNN regularization (*AR* and *TAR*):"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class RNNRegularizer(Callback):\n",
-    "    def __init__(self, alpha=0., beta=0.): self.alpha,self.beta = alpha,beta\n",
-    "\n",
-    "    def after_pred(self):\n",
-    "        self.raw_out,self.out = self.pred[1],self.pred[2]\n",
-    "        self.learn.pred = self.pred[0]\n",
-    "\n",
-    "    def after_loss(self):\n",
-    "        if not self.training: return\n",
-    "        if self.alpha != 0.:\n",
-    "            self.learn.loss += self.alpha * self.out[-1].float().pow(2).mean()\n",
-    "        if self.beta != 0.:\n",
-    "            h = self.raw_out[-1]\n",
-    "            if len(h)>1:\n",
-    "                self.learn.loss += self.beta * (h[:,1:] - h[:,:-1]\n",
-    "                                               ).float().pow(2).mean()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "> stop: Go back to where we discussed TAR and AR regularization, and compare to the code here. Made sure you understand what it's doing, and why."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "In both of these examples, notice how we can access attributes of the training loop by directly checking `self.model` or `self.pred`. That's because a `Callback` will always try to get an attribute it doesn't have inside the `Learner` associated to it. This is a shortcut for `self.learn.model` or `self.learn.pred`. Note that this shortcut works for reading attributes, but not for writing them, which is why when `RNNRegularizer` changes the loss or the predictions, you see `self.learn.loss = ` or `self.learn.pred = `. "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "When writing a callback, the following attributes of `Learner` are available:\n",
-    "\n",
-    "- `model`: the model used for training/validation\n",
-    "- `data`: the underlying `DataLoaders`\n",
-    "- `loss_func`: the loss function used\n",
-    "- `opt`: the optimizer used to udpate the model parameters\n",
-    "- `opt_func`: the function used to create the optimizer\n",
-    "- `cbs`: the list containing all `Callback`s\n",
-    "- `dl`: current `DataLoader` used for iteration\n",
-    "- `x`/`xb`: last input drawn from `self.dl` (potentially modified by callbacks). `xb` is always a tuple (potentially with one element) and `x` is detuplified. You can only assign to `xb`.\n",
-    "- `y`/`yb`: last target drawn from `self.dl` (potentially modified by callbacks). `yb` is always a tuple (potentially with one element) and `y` is detuplified. You can only assign to `yb`.\n",
-    "- `pred`: last predictions from `self.model` (potentially modified by callbacks)\n",
-    "- `loss`: last computed loss (potentially modified by callbacks)\n",
-    "- `n_epoch`: the number of epochs in this training\n",
-    "- `n_iter`: the number of iterations in the current `self.dl`\n",
-    "- `epoch`: the current epoch index (from 0 to `n_epoch-1`)\n",
-    "- `iter`: the current iteration index in `self.dl` (from 0 to `n_iter-1`)\n",
-    "\n",
-    "The following attributes are added by `TrainEvalCallback` and should be available unless you went out of your way to remove that callback:\n",
-    "\n",
-    "- `train_iter`: the number of training iterations done since the beginning of this training\n",
-    "- `pct_train`: from 0. to 1., the percentage of training iterations completed\n",
-    "- `training`:  flag to indicate if we're in training mode or not\n",
-    "\n",
-    "The following attribute is added by `Recorder` and should be available unless you went out of your way to remove that callback:\n",
-    "\n",
-    "- `smooth_loss`: an exponentially-averaged version of the training loss"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Callback ordering and exceptions"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Sometimes, callbacks need to be able to tell fastai to skip over a batch, or an epoch, or stop training altogether. For instance, consider `TerminateOnNaNCallback`. This handy callback will automatically stop training any time the loss becomes infinite or `NaN` (*not a number*). Here's the fastai source for this callback:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class TerminateOnNaNCallback(Callback):\n",
-    "    run_before=Recorder\n",
-    "    def after_batch(self):\n",
-    "        if torch.isinf(self.loss) or torch.isnan(self.loss):\n",
-    "            raise CancelFitException"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "The way it tells the training loop to interrupt training at this point is to `raise CancelFitException`. The training loop catches this exception and does not run any further training or validation. The callback control flow exceptions available are:\n",
-    "\n",
-    "- `CancelFitException`: Skip the rest of this batch and go to `after_batch\n",
-    "- `CancelEpochException`: Skip the rest of the training part of the epoch and go to `after_train\n",
-    "- `CancelTrainException`: Skip the rest of the validation part of the epoch and go to `after_validate\n",
-    "- `CancelValidException`: Skip the rest of this epoch and go to `after_epoch\n",
-    "- `CancelBatchException`: Interrupts training and go to `after_fit"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "You can detect one of those exceptions occurred and add code that executes right after with the following events:\n",
-    "\n",
-    "- `after_cancel_batch`: reached immediately after a `CancelBatchException` before proceeding to `after_batch`\n",
-    "- `after_cancel_train`: reached immediately after a `CancelTrainException` before proceeding to `after_epoch`\n",
-    "- `after_cancel_valid`: reached immediately after a `CancelValidException` before proceeding to `after_epoch`\n",
-    "- `after_cancel_epoch`: reached immediately after a `CancelEpochException` before proceeding to `after_epoch`\n",
-    "- `after_cancel_fit`: reached immediately after a `CancelFitException` before proceeding to `after_fit`"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Sometimes, callbacks need to be called in a particular order. In the case of `TerminateOnNaNCallback`, it's important that `Recorder` runs its `after_batch` after this callback, to avoid registering an NaN loss. You can specify `run_before` (this callback must run before ...) or `run_after` (this callback must run after ...) in your callback to ensure the ordering that you need.\n",
-    "\n",
-    "Now that we have seen how to tweak the training loop of fastai to do anything we need, let's take a step back and dig a little bit deeper in the foundations of that training loop."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Questionnaire"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "1. What are the four steps of a training loop?\n",
-    "1. Why is the use of callbacks better than writing a new training loop for each tweak you want to add?\n",
-    "1. What are the necessary points in the design of the fastai's callback system that make it as flexible as copying and pasting bits of code?\n",
-    "1. How can you get the list of events available to you when writing a callback?\n",
-    "1. Write the `ModelResetter` callback (without peeking).\n",
-    "1. How can you access the necessary attributes of the training loop inside a callback? When can you use or not use the shortcut that goes with it?\n",
-    "1. How can a callback influence the control flow of the training loop.\n",
-    "1. Write the `TerminateOnNaN` callback (without peeking if possible).\n",
-    "1. How do you make sure your callback runs after or before another callback?"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Further research"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "1. Look at the mixed precision callback with the documentation. Try to understand what each event and line of code does.\n",
-    "1. Implement your own version of ther learning rate finder from scratch. Compare it with fastai's version.\n",
-    "1. Look at the source code of the callbacks that ship with fastai. See if you can find one that's similar to what you're looking to do, to get some inspiration."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Foundations of Deep Learning: Wrap up"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Congratulations, you have made it to the end of the \"foundations of deep learning\" section. You now understand how all of fastai's applications and most important architectures are built, and the recommended ways to train them, and have all the information you need to build these from scratch. Whilst you probably won't need to create your own training loop, or batchnorm layer, for instance, knowing what is going on behind the scenes is very helpful for debugging, profiling, and deploying your solutions.\n",
-    "\n",
-    "Since you understand all of the foundations of fastai's applications now, be sure to spend some time digging through fastai's source notebooks, and running and experimenting with parts of them, since you can and see exactly how everything in fastai is developed.\n",
-    "\n",
-    "In the next section, we will be looking even further under the covers, to see how the actual forward and backward passes of a neural network are done, and we will see what tools are at our disposal to get better performance. We will then finish up with a project that brings together everything we have learned throughout the book, which we will use to build a method for interpreting convolutional neural networks."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "jupytext": {
-   "split_at_heading": true
-  },
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.7.5"
-  },
-  "toc": {
-   "base_numbering": 1,
-   "nav_menu": {},
-   "number_sections": false,
-   "sideBar": true,
-   "skip_h1_title": true,
-   "title_cell": "Table of Contents",
-   "title_sidebar": "Contents",
-   "toc_cell": false,
-   "toc_position": {},
-   "toc_section_display": true,
-   "toc_window_display": false
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/21_learner.ipynb b/19_learner.ipynb
similarity index 98%
rename from 21_learner.ipynb
rename to 19_learner.ipynb
index 81054d7..171d96b 100644
--- a/21_learner.ipynb
+++ b/19_learner.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -35,7 +35,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -44,7 +44,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -53,7 +53,7 @@
        "Path('/home/jhoward/.fastai/data/imagenette2-160/val/n03417042/n03417042_3752.JPEG')"
       ]
      },
-     "execution_count": 3,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -65,7 +65,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -74,7 +74,7 @@
        "Path('/home/jhoward/.fastai/data/imagenette2-160/val/n03417042/n03417042_3752.JPEG')"
       ]
      },
-     "execution_count": 4,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -87,7 +87,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -97,7 +97,7 @@
        "<PIL.JpegImagePlugin.JpegImageFile image mode=RGB size=213x160 at 0x7F471FDA55D0>"
       ]
      },
-     "execution_count": 5,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -109,7 +109,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -118,7 +118,7 @@
        "(#10) ['n03417042','n03445777','n03888257','n03394916','n02979186','n03000684','n03425413','n01440764','n03028079','n02102040']"
       ]
      },
-     "execution_count": 6,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -129,7 +129,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -147,7 +147,7 @@
        " 'n02102040': 9}"
       ]
      },
-     "execution_count": 7,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -158,7 +158,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -167,7 +167,7 @@
        "torch.Size([160, 213, 3])"
       ]
      },
-     "execution_count": 8,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -186,7 +186,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -201,7 +201,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -210,7 +210,7 @@
        "(9469, 3925)"
       ]
      },
-     "execution_count": 10,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -223,7 +223,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -232,7 +232,7 @@
        "(torch.Size([64, 64, 3]), tensor(0))"
       ]
      },
-     "execution_count": 11,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -245,7 +245,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -267,7 +267,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -278,7 +278,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -287,7 +287,7 @@
        "(torch.Size([2, 64, 64, 3]), tensor([0, 0]))"
       ]
      },
-     "execution_count": 14,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -299,7 +299,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -319,7 +319,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -328,7 +328,7 @@
        "(torch.Size([128, 64, 64, 3]), torch.Size([128]), 74)"
       ]
      },
-     "execution_count": 16,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -343,7 +343,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -352,7 +352,7 @@
        "[tensor([0.4544, 0.4453, 0.4141]), tensor([0.2812, 0.2766, 0.2981])]"
       ]
      },
-     "execution_count": 17,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -364,7 +364,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -378,7 +378,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -388,7 +388,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -397,7 +397,7 @@
        "(tensor([0.3732, 0.4907, 0.5633]), tensor([1.0212, 1.0311, 1.0131]))"
       ]
      },
-     "execution_count": 20,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -416,7 +416,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -427,7 +427,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -466,7 +466,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -475,7 +475,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -496,7 +496,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -505,7 +505,7 @@
        "2"
       ]
      },
-     "execution_count": 26,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -517,7 +517,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -526,7 +526,7 @@
        "torch.Size([128, 4, 64, 64])"
       ]
      },
-     "execution_count": 27,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -539,7 +539,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -555,7 +555,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -564,7 +564,7 @@
        "torch.Size([3, 2])"
       ]
      },
-     "execution_count": 29,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -577,7 +577,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -589,7 +589,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -598,7 +598,7 @@
        "4"
       ]
      },
-     "execution_count": 31,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -610,7 +610,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -619,7 +619,7 @@
        "device(type='cuda', index=5)"
       ]
      },
-     "execution_count": 32,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -638,7 +638,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 33,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -655,7 +655,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 34,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -665,7 +665,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 35,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -682,7 +682,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 36,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -691,7 +691,7 @@
        "10"
       ]
      },
-     "execution_count": 36,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -703,7 +703,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 37,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -713,7 +713,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 38,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -732,7 +732,7 @@
        "torch.Size([128, 10])"
       ]
      },
-     "execution_count": 38,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -751,7 +751,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 39,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -767,7 +767,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 40,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -776,7 +776,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 41,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -785,7 +785,7 @@
        "tensor(-2.7753, grad_fn=<SelectBackward>)"
       ]
      },
-     "execution_count": 41,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -796,7 +796,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 42,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -805,7 +805,7 @@
        "tensor(2.5293, grad_fn=<NegBackward>)"
       ]
      },
-     "execution_count": 42,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -828,7 +828,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 43,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -837,7 +837,7 @@
        "tensor(-2.7753, grad_fn=<SelectBackward>)"
       ]
      },
-     "execution_count": 43,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -863,7 +863,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 44,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -872,7 +872,7 @@
        "tensor(False)"
       ]
      },
-     "execution_count": 44,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -885,7 +885,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 45,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -896,7 +896,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 46,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -905,7 +905,7 @@
        "tensor(2.3158, grad_fn=<SelectBackward>)"
       ]
      },
-     "execution_count": 46,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -923,7 +923,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 47,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -932,7 +932,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 48,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -941,7 +941,7 @@
        "tensor(-2.7753, grad_fn=<SelectBackward>)"
       ]
      },
-     "execution_count": 48,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -952,7 +952,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 49,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -968,7 +968,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 50,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -982,7 +982,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 51,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -992,7 +992,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 52,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1001,7 +1001,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 53,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1045,7 +1045,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 54,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1054,7 +1054,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 55,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1077,7 +1077,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 56,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1091,7 +1091,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 57,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1100,7 +1100,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 58,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1109,7 +1109,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 75,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -1160,7 +1160,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 59,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1182,7 +1182,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 60,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1191,7 +1191,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 61,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1200,7 +1200,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 62,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -1273,7 +1273,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 113,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -1296,7 +1296,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 136,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1323,7 +1323,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 137,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1332,7 +1332,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 138,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1341,7 +1341,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 139,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -1623,7 +1623,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 140,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -1731,34 +1731,6 @@
    "display_name": "Python 3",
    "language": "python",
    "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.7.5"
-  },
-  "toc": {
-   "base_numbering": 1,
-   "nav_menu": {
-    "height": "140px",
-    "width": "202px"
-   },
-   "number_sections": false,
-   "sideBar": true,
-   "skip_h1_title": true,
-   "title_cell": "Table of Contents",
-   "title_sidebar": "Contents",
-   "toc_cell": false,
-   "toc_position": {},
-   "toc_section_display": true,
-   "toc_window_display": false
   }
  },
  "nbformat": 4,
diff --git a/22_conclusion.ipynb b/20_conclusion.ipynb
similarity index 95%
rename from 22_conclusion.ipynb
rename to 20_conclusion.ipynb
index 32efd3e..1ad376e 100644
--- a/22_conclusion.ipynb
+++ b/20_conclusion.ipynb
@@ -20,7 +20,7 @@
    "source": [
     "Congratulations! You've made it! If you have worked through all of the notebooks to this point, then you have joined a small, but growing group of people that are able to harness the power of deep learning to solve real problems. You may not feel that way; in fact you probably do not feel that way. We have seen again and again that students that complete the fast.AI courses dramatically underestimate how effective they are as deep learning practitioners. We've also seen that these people are often underestimated by those that have come out of a classic academic background. So for you to rise above your own expectations and the expectations of others what you do next, after closing this book, is even more important than what you've done to get to this point.\n",
     "\n",
-    "The most important thing is to keep the momentum going. In fact, as you know from your study of optimisers, momentum is something which can build upon itself! So think about what it is you can do now to maintain and accelerate your deep learning journey. Here's a few ideas:"
+    "The most important thing is to keep the momentum going. In fact, as you know from your study of optimisers, momentum is something which can build upon itself! So think about what it is you can do now to maintain and accelerate your deep learning journey. <<do_next>> can give you a few ideas."
    ]
   },
   {
@@ -69,18 +69,6 @@
    "display_name": "Python 3",
    "language": "python",
    "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.7.3"
   }
  },
  "nbformat": 4,