diff --git a/tutorials/W1D1_Generalization/W1D1_Tutorial1.ipynb b/tutorials/W1D1_Generalization/W1D1_Tutorial1.ipynb index e7bde0c72..35e8bd14a 100644 --- a/tutorials/W1D1_Generalization/W1D1_Tutorial1.ipynb +++ b/tutorials/W1D1_Generalization/W1D1_Tutorial1.ipynb @@ -13,10 +13,8 @@ "Defaulting to user installation because normal site-packages is not writeable\n", "Requirement already satisfied: transformers in /home/samuele/.local/lib/python3.10/site-packages (4.36.2)\n", "Requirement already satisfied: gradio in /home/samuele/.local/lib/python3.10/site-packages (4.12.0)\n", - "Collecting sentencepiece\n", - " Downloading sentencepiece-0.1.99-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.3 MB)\n", - "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.3/1.3 MB\u001b[0m \u001b[31m4.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m:01\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from transformers) (3.8.0)\n", + "Requirement already satisfied: sentencepiece in /home/samuele/.local/lib/python3.10/site-packages (0.1.99)\n", + "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from transformers) (3.8.0)\n", "Requirement already satisfied: huggingface-hub<1.0,>=0.19.3 in /home/samuele/.local/lib/python3.10/site-packages (from transformers) (0.20.1)\n", "Requirement already satisfied: numpy>=1.17 in /home/samuele/.local/lib/python3.10/site-packages (from transformers) (1.23.4)\n", "Requirement already satisfied: packaging>=20.0 in /home/samuele/.local/lib/python3.10/site-packages (from transformers) (21.3)\n", @@ -38,7 +36,7 @@ "Requirement already satisfied: matplotlib~=3.0 in /home/samuele/.local/lib/python3.10/site-packages (from gradio) (3.6.2)\n", "Requirement already satisfied: orjson~=3.0 in /home/samuele/.local/lib/python3.10/site-packages (from gradio) (3.9.10)\n", "Requirement already satisfied: pandas<3.0,>=1.0 in /home/samuele/.local/lib/python3.10/site-packages (from gradio) (1.5.1)\n", - "Requirement already satisfied: pillow<11.0,>=8.0 in /usr/lib/python3/dist-packages (from gradio) (9.0.1)\n", + "Requirement already satisfied: pillow<11.0,>=8.0 in /home/samuele/.local/lib/python3.10/site-packages (from gradio) (9.5.0)\n", "Requirement already satisfied: pydantic>=2.0 in /home/samuele/.local/lib/python3.10/site-packages (from gradio) (2.5.3)\n", "Requirement already satisfied: pydub in /home/samuele/.local/lib/python3.10/site-packages (from gradio) (0.25.1)\n", "Requirement already satisfied: python-multipart in /home/samuele/.local/lib/python3.10/site-packages (from gradio) (0.0.6)\n", @@ -83,38 +81,144 @@ "Requirement already satisfied: pygments<3.0.0,>=2.13.0 in /home/samuele/.local/lib/python3.10/site-packages (from rich<14.0.0,>=10.11.0->typer[all]<1.0,>=0.9->gradio) (2.17.2)\n", "Requirement already satisfied: mdurl~=0.1 in /home/samuele/.local/lib/python3.10/site-packages (from markdown-it-py>=2.2.0->rich<14.0.0,>=10.11.0->typer[all]<1.0,>=0.9->gradio) (0.1.2)\n", "\u001b[33mDEPRECATION: omegaconf 2.0.6 has a non-standard dependency specifier PyYAML>=5.1.*. pip 24.0 will enforce this behaviour change. A possible replacement is to upgrade to a newer version of omegaconf or contact the author to suggest that they release a version with a conforming dependency specifiers. Discussion can be found at https://github.com/pypa/pip/issues/12063\u001b[0m\u001b[33m\n", - "\u001b[0mInstalling collected packages: sentencepiece\n", - "Successfully installed sentencepiece-0.1.99\n" + "\u001b[0mDefaulting to user installation because normal site-packages is not writeable\n", + "Requirement already satisfied: numpy in /home/samuele/.local/lib/python3.10/site-packages (1.23.4)\n", + "\u001b[33mDEPRECATION: omegaconf 2.0.6 has a non-standard dependency specifier PyYAML>=5.1.*. pip 24.0 will enforce this behaviour change. A possible replacement is to upgrade to a newer version of omegaconf or contact the author to suggest that they release a version with a conforming dependency specifiers. Discussion can be found at https://github.com/pypa/pip/issues/12063\u001b[0m\u001b[33m\n", + "\u001b[0m" ] } ], "source": [ "# Install \n", "!pip install transformers gradio sentencepiece\n", - "\n", + "!pip install numpy \n", "\n" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 2, "id": "b00326ca-807d-460f-adf4-767e94bc0ccc", "metadata": {}, "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d32bdcc145fd4e6f8f0b12d2d26be648", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "config.json: 0%| | 0.00/4.21k [00:00" + "
" ], "text/plain": [ "" @@ -135,7 +239,7 @@ "data": { "text/plain": [] }, - "execution_count": 7, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } @@ -171,11 +275,1000 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "3b9b10a2-a46c-4fe0-ad47-a059b110209f", "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Some weights of VisionEncoderDecoderModel were not initialized from the model checkpoint at microsoft/trocr-small-handwritten and are newly initialized: ['encoder.pooler.dense.bias', 'encoder.pooler.dense.weight']\n", + "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n" + ] + } + ], + "source": [ + "#Imports\n", + "from transformers import TrOCRProcessor, VisionEncoderDecoderModel\n", + "\n", + "# Load the model\n", + "model = VisionEncoderDecoderModel.from_pretrained(\"microsoft/trocr-small-handwritten\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "d62cd9c9-95fb-4541-9ece-78620745ee1f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "DeiTModel(\n", + " (embeddings): DeiTEmbeddings(\n", + " (patch_embeddings): DeiTPatchEmbeddings(\n", + " (projection): Conv2d(3, 384, kernel_size=(16, 16), stride=(16, 16))\n", + " )\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (encoder): DeiTEncoder(\n", + " (layer): ModuleList(\n", + " (0): DeiTLayer(\n", + " (attention): DeiTAttention(\n", + " (attention): DeiTSelfAttention(\n", + " (query): Linear(in_features=384, out_features=384, bias=True)\n", + " (key): Linear(in_features=384, out_features=384, bias=True)\n", + " (value): Linear(in_features=384, out_features=384, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (output): DeiTSelfOutput(\n", + " (dense): Linear(in_features=384, out_features=384, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (intermediate): DeiTIntermediate(\n", + " (dense): Linear(in_features=384, out_features=1536, bias=True)\n", + " (intermediate_act_fn): GELUActivation()\n", + " )\n", + " (output): DeiTOutput(\n", + " (dense): Linear(in_features=1536, out_features=384, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (layernorm_before): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", + " (layernorm_after): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", + " )\n", + " (1): DeiTLayer(\n", + " (attention): DeiTAttention(\n", + " (attention): DeiTSelfAttention(\n", + " (query): Linear(in_features=384, out_features=384, bias=True)\n", + " (key): Linear(in_features=384, out_features=384, bias=True)\n", + " (value): Linear(in_features=384, out_features=384, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (output): DeiTSelfOutput(\n", + " (dense): Linear(in_features=384, out_features=384, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (intermediate): DeiTIntermediate(\n", + " (dense): Linear(in_features=384, out_features=1536, bias=True)\n", + " (intermediate_act_fn): GELUActivation()\n", + " )\n", + " (output): DeiTOutput(\n", + " (dense): Linear(in_features=1536, out_features=384, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (layernorm_before): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", + " (layernorm_after): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", + " )\n", + " (2): DeiTLayer(\n", + " (attention): DeiTAttention(\n", + " (attention): DeiTSelfAttention(\n", + " (query): Linear(in_features=384, out_features=384, bias=True)\n", + " (key): Linear(in_features=384, out_features=384, bias=True)\n", + " (value): Linear(in_features=384, out_features=384, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (output): DeiTSelfOutput(\n", + " (dense): Linear(in_features=384, out_features=384, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (intermediate): DeiTIntermediate(\n", + " (dense): Linear(in_features=384, out_features=1536, bias=True)\n", + " (intermediate_act_fn): GELUActivation()\n", + " )\n", + " (output): DeiTOutput(\n", + " (dense): Linear(in_features=1536, out_features=384, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (layernorm_before): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", + " (layernorm_after): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", + " )\n", + " (3): DeiTLayer(\n", + " (attention): DeiTAttention(\n", + " (attention): DeiTSelfAttention(\n", + " (query): Linear(in_features=384, out_features=384, bias=True)\n", + " (key): Linear(in_features=384, out_features=384, bias=True)\n", + " (value): Linear(in_features=384, out_features=384, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (output): DeiTSelfOutput(\n", + " (dense): Linear(in_features=384, out_features=384, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (intermediate): DeiTIntermediate(\n", + " (dense): Linear(in_features=384, out_features=1536, bias=True)\n", + " (intermediate_act_fn): GELUActivation()\n", + " )\n", + " (output): DeiTOutput(\n", + " (dense): Linear(in_features=1536, out_features=384, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (layernorm_before): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", + " (layernorm_after): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", + " )\n", + " (4): DeiTLayer(\n", + " (attention): DeiTAttention(\n", + " (attention): DeiTSelfAttention(\n", + " (query): Linear(in_features=384, out_features=384, bias=True)\n", + " (key): Linear(in_features=384, out_features=384, bias=True)\n", + " (value): Linear(in_features=384, out_features=384, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (output): DeiTSelfOutput(\n", + " (dense): Linear(in_features=384, out_features=384, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (intermediate): DeiTIntermediate(\n", + " (dense): Linear(in_features=384, out_features=1536, bias=True)\n", + " (intermediate_act_fn): GELUActivation()\n", + " )\n", + " (output): DeiTOutput(\n", + " (dense): Linear(in_features=1536, out_features=384, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (layernorm_before): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", + " (layernorm_after): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", + " )\n", + " (5): DeiTLayer(\n", + " (attention): DeiTAttention(\n", + " (attention): DeiTSelfAttention(\n", + " (query): Linear(in_features=384, out_features=384, bias=True)\n", + " (key): Linear(in_features=384, out_features=384, bias=True)\n", + " (value): Linear(in_features=384, out_features=384, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (output): DeiTSelfOutput(\n", + " (dense): Linear(in_features=384, out_features=384, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (intermediate): DeiTIntermediate(\n", + " (dense): Linear(in_features=384, out_features=1536, bias=True)\n", + " (intermediate_act_fn): GELUActivation()\n", + " )\n", + " (output): DeiTOutput(\n", + " (dense): Linear(in_features=1536, out_features=384, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (layernorm_before): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", + " (layernorm_after): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", + " )\n", + " (6): DeiTLayer(\n", + " (attention): DeiTAttention(\n", + " (attention): DeiTSelfAttention(\n", + " (query): Linear(in_features=384, out_features=384, bias=True)\n", + " (key): Linear(in_features=384, out_features=384, bias=True)\n", + " (value): Linear(in_features=384, out_features=384, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (output): DeiTSelfOutput(\n", + " (dense): Linear(in_features=384, out_features=384, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (intermediate): DeiTIntermediate(\n", + " (dense): Linear(in_features=384, out_features=1536, bias=True)\n", + " (intermediate_act_fn): GELUActivation()\n", + " )\n", + " (output): DeiTOutput(\n", + " (dense): Linear(in_features=1536, out_features=384, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (layernorm_before): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", + " (layernorm_after): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", + " )\n", + " (7): DeiTLayer(\n", + " (attention): DeiTAttention(\n", + " (attention): DeiTSelfAttention(\n", + " (query): Linear(in_features=384, out_features=384, bias=True)\n", + " (key): Linear(in_features=384, out_features=384, bias=True)\n", + " (value): Linear(in_features=384, out_features=384, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (output): DeiTSelfOutput(\n", + " (dense): Linear(in_features=384, out_features=384, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (intermediate): DeiTIntermediate(\n", + " (dense): Linear(in_features=384, out_features=1536, bias=True)\n", + " (intermediate_act_fn): GELUActivation()\n", + " )\n", + " (output): DeiTOutput(\n", + " (dense): Linear(in_features=1536, out_features=384, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (layernorm_before): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", + " (layernorm_after): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", + " )\n", + " (8): DeiTLayer(\n", + " (attention): DeiTAttention(\n", + " (attention): DeiTSelfAttention(\n", + " (query): Linear(in_features=384, out_features=384, bias=True)\n", + " (key): Linear(in_features=384, out_features=384, bias=True)\n", + " (value): Linear(in_features=384, out_features=384, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (output): DeiTSelfOutput(\n", + " (dense): Linear(in_features=384, out_features=384, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (intermediate): DeiTIntermediate(\n", + " (dense): Linear(in_features=384, out_features=1536, bias=True)\n", + " (intermediate_act_fn): GELUActivation()\n", + " )\n", + " (output): DeiTOutput(\n", + " (dense): Linear(in_features=1536, out_features=384, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (layernorm_before): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", + " (layernorm_after): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", + " )\n", + " (9): DeiTLayer(\n", + " (attention): DeiTAttention(\n", + " (attention): DeiTSelfAttention(\n", + " (query): Linear(in_features=384, out_features=384, bias=True)\n", + " (key): Linear(in_features=384, out_features=384, bias=True)\n", + " (value): Linear(in_features=384, out_features=384, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (output): DeiTSelfOutput(\n", + " (dense): Linear(in_features=384, out_features=384, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (intermediate): DeiTIntermediate(\n", + " (dense): Linear(in_features=384, out_features=1536, bias=True)\n", + " (intermediate_act_fn): GELUActivation()\n", + " )\n", + " (output): DeiTOutput(\n", + " (dense): Linear(in_features=1536, out_features=384, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (layernorm_before): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", + " (layernorm_after): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", + " )\n", + " (10): DeiTLayer(\n", + " (attention): DeiTAttention(\n", + " (attention): DeiTSelfAttention(\n", + " (query): Linear(in_features=384, out_features=384, bias=True)\n", + " (key): Linear(in_features=384, out_features=384, bias=True)\n", + " (value): Linear(in_features=384, out_features=384, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (output): DeiTSelfOutput(\n", + " (dense): Linear(in_features=384, out_features=384, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (intermediate): DeiTIntermediate(\n", + " (dense): Linear(in_features=384, out_features=1536, bias=True)\n", + " (intermediate_act_fn): GELUActivation()\n", + " )\n", + " (output): DeiTOutput(\n", + " (dense): Linear(in_features=1536, out_features=384, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (layernorm_before): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", + " (layernorm_after): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", + " )\n", + " (11): DeiTLayer(\n", + " (attention): DeiTAttention(\n", + " (attention): DeiTSelfAttention(\n", + " (query): Linear(in_features=384, out_features=384, bias=True)\n", + " (key): Linear(in_features=384, out_features=384, bias=True)\n", + " (value): Linear(in_features=384, out_features=384, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (output): DeiTSelfOutput(\n", + " (dense): Linear(in_features=384, out_features=384, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (intermediate): DeiTIntermediate(\n", + " (dense): Linear(in_features=384, out_features=1536, bias=True)\n", + " (intermediate_act_fn): GELUActivation()\n", + " )\n", + " (output): DeiTOutput(\n", + " (dense): Linear(in_features=1536, out_features=384, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (layernorm_before): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", + " (layernorm_after): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", + " )\n", + " )\n", + " )\n", + " (layernorm): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", + " (pooler): DeiTPooler(\n", + " (dense): Linear(in_features=384, out_features=384, bias=True)\n", + " (activation): Tanh()\n", + " )\n", + ")" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Inspect the encoder of the model\n", + "model.encoder\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "69695c6c-0ba3-426d-8af1-ab7e845dba14", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "TrOCRForCausalLM(\n", + " (model): TrOCRDecoderWrapper(\n", + " (decoder): TrOCRDecoder(\n", + " (embed_tokens): Embedding(64044, 256, padding_idx=1)\n", + " (embed_positions): TrOCRLearnedPositionalEmbedding(514, 256)\n", + " (layernorm_embedding): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (layers): ModuleList(\n", + " (0): TrOCRDecoderLayer(\n", + " (self_attn): TrOCRAttention(\n", + " (k_proj): Linear(in_features=256, out_features=256, bias=True)\n", + " (v_proj): Linear(in_features=256, out_features=256, bias=True)\n", + " (q_proj): Linear(in_features=256, out_features=256, bias=True)\n", + " (out_proj): Linear(in_features=256, out_features=256, bias=True)\n", + " )\n", + " (activation_fn): ReLU()\n", + " (self_attn_layer_norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (encoder_attn): TrOCRAttention(\n", + " (k_proj): Linear(in_features=384, out_features=256, bias=True)\n", + " (v_proj): Linear(in_features=384, out_features=256, bias=True)\n", + " (q_proj): Linear(in_features=256, out_features=256, bias=True)\n", + " (out_proj): Linear(in_features=256, out_features=256, bias=True)\n", + " )\n", + " (encoder_attn_layer_norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (fc1): Linear(in_features=256, out_features=1024, bias=True)\n", + " (fc2): Linear(in_features=1024, out_features=256, bias=True)\n", + " (final_layer_norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " )\n", + " (1): TrOCRDecoderLayer(\n", + " (self_attn): TrOCRAttention(\n", + " (k_proj): Linear(in_features=256, out_features=256, bias=True)\n", + " (v_proj): Linear(in_features=256, out_features=256, bias=True)\n", + " (q_proj): Linear(in_features=256, out_features=256, bias=True)\n", + " (out_proj): Linear(in_features=256, out_features=256, bias=True)\n", + " )\n", + " (activation_fn): ReLU()\n", + " (self_attn_layer_norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (encoder_attn): TrOCRAttention(\n", + " (k_proj): Linear(in_features=384, out_features=256, bias=True)\n", + " (v_proj): Linear(in_features=384, out_features=256, bias=True)\n", + " (q_proj): Linear(in_features=256, out_features=256, bias=True)\n", + " (out_proj): Linear(in_features=256, out_features=256, bias=True)\n", + " )\n", + " (encoder_attn_layer_norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (fc1): Linear(in_features=256, out_features=1024, bias=True)\n", + " (fc2): Linear(in_features=1024, out_features=256, bias=True)\n", + " (final_layer_norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " )\n", + " (2): TrOCRDecoderLayer(\n", + " (self_attn): TrOCRAttention(\n", + " (k_proj): Linear(in_features=256, out_features=256, bias=True)\n", + " (v_proj): Linear(in_features=256, out_features=256, bias=True)\n", + " (q_proj): Linear(in_features=256, out_features=256, bias=True)\n", + " (out_proj): Linear(in_features=256, out_features=256, bias=True)\n", + " )\n", + " (activation_fn): ReLU()\n", + " (self_attn_layer_norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (encoder_attn): TrOCRAttention(\n", + " (k_proj): Linear(in_features=384, out_features=256, bias=True)\n", + " (v_proj): Linear(in_features=384, out_features=256, bias=True)\n", + " (q_proj): Linear(in_features=256, out_features=256, bias=True)\n", + " (out_proj): Linear(in_features=256, out_features=256, bias=True)\n", + " )\n", + " (encoder_attn_layer_norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (fc1): Linear(in_features=256, out_features=1024, bias=True)\n", + " (fc2): Linear(in_features=1024, out_features=256, bias=True)\n", + " (final_layer_norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " )\n", + " (3): TrOCRDecoderLayer(\n", + " (self_attn): TrOCRAttention(\n", + " (k_proj): Linear(in_features=256, out_features=256, bias=True)\n", + " (v_proj): Linear(in_features=256, out_features=256, bias=True)\n", + " (q_proj): Linear(in_features=256, out_features=256, bias=True)\n", + " (out_proj): Linear(in_features=256, out_features=256, bias=True)\n", + " )\n", + " (activation_fn): ReLU()\n", + " (self_attn_layer_norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (encoder_attn): TrOCRAttention(\n", + " (k_proj): Linear(in_features=384, out_features=256, bias=True)\n", + " (v_proj): Linear(in_features=384, out_features=256, bias=True)\n", + " (q_proj): Linear(in_features=256, out_features=256, bias=True)\n", + " (out_proj): Linear(in_features=256, out_features=256, bias=True)\n", + " )\n", + " (encoder_attn_layer_norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (fc1): Linear(in_features=256, out_features=1024, bias=True)\n", + " (fc2): Linear(in_features=1024, out_features=256, bias=True)\n", + " (final_layer_norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " )\n", + " (4): TrOCRDecoderLayer(\n", + " (self_attn): TrOCRAttention(\n", + " (k_proj): Linear(in_features=256, out_features=256, bias=True)\n", + " (v_proj): Linear(in_features=256, out_features=256, bias=True)\n", + " (q_proj): Linear(in_features=256, out_features=256, bias=True)\n", + " (out_proj): Linear(in_features=256, out_features=256, bias=True)\n", + " )\n", + " (activation_fn): ReLU()\n", + " (self_attn_layer_norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (encoder_attn): TrOCRAttention(\n", + " (k_proj): Linear(in_features=384, out_features=256, bias=True)\n", + " (v_proj): Linear(in_features=384, out_features=256, bias=True)\n", + " (q_proj): Linear(in_features=256, out_features=256, bias=True)\n", + " (out_proj): Linear(in_features=256, out_features=256, bias=True)\n", + " )\n", + " (encoder_attn_layer_norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (fc1): Linear(in_features=256, out_features=1024, bias=True)\n", + " (fc2): Linear(in_features=1024, out_features=256, bias=True)\n", + " (final_layer_norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " )\n", + " (5): TrOCRDecoderLayer(\n", + " (self_attn): TrOCRAttention(\n", + " (k_proj): Linear(in_features=256, out_features=256, bias=True)\n", + " (v_proj): Linear(in_features=256, out_features=256, bias=True)\n", + " (q_proj): Linear(in_features=256, out_features=256, bias=True)\n", + " (out_proj): Linear(in_features=256, out_features=256, bias=True)\n", + " )\n", + " (activation_fn): ReLU()\n", + " (self_attn_layer_norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (encoder_attn): TrOCRAttention(\n", + " (k_proj): Linear(in_features=384, out_features=256, bias=True)\n", + " (v_proj): Linear(in_features=384, out_features=256, bias=True)\n", + " (q_proj): Linear(in_features=256, out_features=256, bias=True)\n", + " (out_proj): Linear(in_features=256, out_features=256, bias=True)\n", + " )\n", + " (encoder_attn_layer_norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (fc1): Linear(in_features=256, out_features=1024, bias=True)\n", + " (fc2): Linear(in_features=1024, out_features=256, bias=True)\n", + " (final_layer_norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " )\n", + " )\n", + " )\n", + " )\n", + " (output_projection): Linear(in_features=256, out_features=64044, bias=False)\n", + ")" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Inspect the decoder of the model\n", + "model.decoder" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "df898317-31e6-4b28-9175-c1206b255a98", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(21960192, 39636480)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Function to count the parameters of the model\n", + "def count_parameters(model):\n", + " return sum(p.numel() for p in model.parameters())\n", + "\n", + "# Count parameters in the encoder\n", + "encoder_params = count_parameters(model.encoder)\n", + "\n", + "# Count parameters in the decoder\n", + "decoder_params = count_parameters(model.decoder)\n", + "\n", + "encoder_params, decoder_params\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "bf37c12f-77c3-4b90-841d-901b0ee4bb8c", + "metadata": {}, "outputs": [], - "source": [] + "source": [ + "# Imports\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "b7ada4c5-ea4f-4feb-917d-1f9b43b11865", + "metadata": {}, + "outputs": [], + "source": [ + "def calculate_writing_time(total_words, words_per_day, days_per_week, weeks_per_year, average_human_lifespan):\n", + " \"\"\"\n", + " Calculate the time required to write a given number of words in lifetimes.\n", + "\n", + " Parameters:\n", + " - total_words: total number of words to be written.\n", + " - words_per_day: number of words written per day.\n", + " - days_per_week: number of days dedicated to writing per week.\n", + " - weeks_per_year: number of weeks dedicated to writing per year.\n", + " - average_human_lifespan: average lifespan of a human in years.\n", + "\n", + " Returns:\n", + " - time_to_write_lifetimes: time to write the given words in lifetimes.\n", + " \"\"\"\n", + "\n", + " #################################################\n", + " ## TODO for students: fill in the missing variables ##\n", + " # Fill out function and remove\n", + " raise NotImplementedError(\"Student exercise: fill in the missing variables\")\n", + " #################################################\n", + " \n", + " words_per_year = words_per_day * days_per_week * weeks_per_year\n", + "\n", + " # Calculate the time to write in years\n", + " time_to_write_years = total_words / ... \n", + "\n", + " # Calculate the time to write in lifetimes\n", + " time_to_write_lifetimes = time_to_write_years / average_human_lifespan\n", + "\n", + " return time_to_write_lifetimes\n", + "\n", + "# Example values\n", + "total_words = 5e9\n", + "words_per_day = 1500\n", + "days_per_week = 6\n", + "weeks_per_year = 50\n", + "average_human_lifespan = 80\n", + "\n", + "# Uncomment the code below to test your function\n", + "\n", + "# Test the function\n", + "#time_to_write_lifetimes_roberta = calculate_writing_time(\n", + " #total_words, \n", + " #words_per_day, \n", + " #days_per_week, \n", + " #weeks_per_year, \n", + " #average_human_lifespan\n", + "#)\n", + "\n", + "# Print the result\n", + "#print(f\"Time to write {total_words} words in lifetimes: {time_to_write_lifetimes_roberta} lifetimes\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "8a6127df-6dde-445f-8b49-3df6ba9064fb", + "metadata": {}, + "outputs": [], + "source": [ + "# to_remove solution\n", + "def calculate_writing_time(total_words, words_per_day, days_per_week, weeks_per_year, average_human_lifespan):\n", + " \"\"\"\n", + " Calculate the time required to write a given number of words in lifetimes.\n", + "\n", + " Parameters:\n", + " - total_words: total number of words to be written.\n", + " - words_per_day: number of words written per day.\n", + " - days_per_week: number of days dedicated to writing per week.\n", + " - weeks_per_year: number of weeks dedicated to writing per year.\n", + " - average_human_lifespan: average lifespan of a human in years.\n", + "\n", + " Returns:\n", + " - time_to_write_lifetimes: time to write the given words in lifetimes.\n", + " \"\"\"\n", + " \n", + " words_per_year = words_per_day * days_per_week * weeks_per_year\n", + "\n", + " # Calculate the time to write in years\n", + " time_to_write_years = total_words / words_per_year \n", + "\n", + " # Calculate the time to write in lifetimes\n", + " time_to_write_lifetimes = time_to_write_years / average_human_lifespan\n", + "\n", + " return time_to_write_lifetimes\n", + "\n", + "# Example values\n", + "total_words = 5e9\n", + "words_per_day = 1500\n", + "days_per_week = 6\n", + "weeks_per_year = 50\n", + "average_human_lifespan = 80\n", + "\n", + "# Uncomment the code below to test your function\n", + "\n", + "# Test the function\n", + "#time_to_write_lifetimes_roberta = calculate_writing_time(\n", + " #total_words, \n", + " #words_per_day, \n", + " #days_per_week, \n", + " #weeks_per_year, \n", + " #average_human_lifespan\n", + "#)\n", + "\n", + "# Print the result\n", + "#print(f\"Time to write {total_words} words in lifetimes: {time_to_write_lifetimes_roberta} lifetimes\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "a19006eb-4600-4aa4-9c99-b85b5e4a87c5", + "metadata": {}, + "outputs": [], + "source": [ + "#Exploring Llama 2\n", + "total_tokens_llama2 = 2e12\n", + "total_words_llama2 = 2e12 / 1.5 #assuming 1.5 words per token" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "a785a098-d6ff-48a8-8b57-3e0e9e436ffe", + "metadata": {}, + "outputs": [], + "source": [ + "# Time to generate text\n", + "time_to_write_lifetimes_llama = calculate_writing_time(total_words_llama2, words_per_day, days_per_week, weeks_per_year, average_human_lifespan)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "76cafcd3-4c19-4a5d-a9b5-c0c65e1c777a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Defaulting to user installation because normal site-packages is not writeable\n", + "Requirement already satisfied: torch in /home/samuele/.local/lib/python3.10/site-packages (1.13.0)\n", + "Requirement already satisfied: torchvision in /home/samuele/.local/lib/python3.10/site-packages (0.14.0)\n", + "Requirement already satisfied: trdg in /home/samuele/.local/lib/python3.10/site-packages (1.8.0)\n", + "Requirement already satisfied: typing-extensions in /home/samuele/.local/lib/python3.10/site-packages (from torch) (4.9.0)\n", + "Requirement already satisfied: nvidia-cuda-runtime-cu11==11.7.99 in /home/samuele/.local/lib/python3.10/site-packages (from torch) (11.7.99)\n", + "Requirement already satisfied: nvidia-cudnn-cu11==8.5.0.96 in /home/samuele/.local/lib/python3.10/site-packages (from torch) (8.5.0.96)\n", + "Requirement already satisfied: nvidia-cublas-cu11==11.10.3.66 in /home/samuele/.local/lib/python3.10/site-packages (from torch) (11.10.3.66)\n", + "Requirement already satisfied: nvidia-cuda-nvrtc-cu11==11.7.99 in /home/samuele/.local/lib/python3.10/site-packages (from torch) (11.7.99)\n", + "Requirement already satisfied: setuptools in /usr/lib/python3/dist-packages (from nvidia-cublas-cu11==11.10.3.66->torch) (59.6.0)\n", + "Requirement already satisfied: wheel in /usr/lib/python3/dist-packages (from nvidia-cublas-cu11==11.10.3.66->torch) (0.37.1)\n", + "Requirement already satisfied: numpy in /home/samuele/.local/lib/python3.10/site-packages (from torchvision) (1.23.4)\n", + "Requirement already satisfied: requests in /home/samuele/.local/lib/python3.10/site-packages (from torchvision) (2.31.0)\n", + "Requirement already satisfied: pillow!=8.3.*,>=5.3.0 in /home/samuele/.local/lib/python3.10/site-packages (from torchvision) (9.5.0)\n", + "Requirement already satisfied: opencv-python>=4.2.0.32 in /home/samuele/.local/lib/python3.10/site-packages (from trdg) (4.9.0.80)\n", + "Requirement already satisfied: tqdm>=4.23.0 in /home/samuele/.local/lib/python3.10/site-packages (from trdg) (4.66.1)\n", + "Requirement already satisfied: wikipedia>=1.4.0 in /home/samuele/.local/lib/python3.10/site-packages (from trdg) (1.4.0)\n", + "Requirement already satisfied: diffimg==0.2.3 in /home/samuele/.local/lib/python3.10/site-packages (from trdg) (0.2.3)\n", + "Requirement already satisfied: arabic-reshaper==2.1.3 in /home/samuele/.local/lib/python3.10/site-packages (from trdg) (2.1.3)\n", + "Requirement already satisfied: python-bidi==0.4.2 in /home/samuele/.local/lib/python3.10/site-packages (from trdg) (0.4.2)\n", + "Requirement already satisfied: future in /usr/lib/python3/dist-packages (from arabic-reshaper==2.1.3->trdg) (0.18.2)\n", + "Requirement already satisfied: six in /usr/lib/python3/dist-packages (from python-bidi==0.4.2->trdg) (1.16.0)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /home/samuele/.local/lib/python3.10/site-packages (from requests->torchvision) (3.3.2)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/lib/python3/dist-packages (from requests->torchvision) (3.3)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /home/samuele/.local/lib/python3.10/site-packages (from requests->torchvision) (1.26.14)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/lib/python3/dist-packages (from requests->torchvision) (2020.6.20)\n", + "Requirement already satisfied: beautifulsoup4 in /usr/lib/python3/dist-packages (from wikipedia>=1.4.0->trdg) (4.10.0)\n", + "\u001b[33mDEPRECATION: omegaconf 2.0.6 has a non-standard dependency specifier PyYAML>=5.1.*. pip 24.0 will enforce this behaviour change. A possible replacement is to upgrade to a newer version of omegaconf or contact the author to suggest that they release a version with a conforming dependency specifiers. Discussion can be found at https://github.com/pypa/pip/issues/12063\u001b[0m\u001b[33m\n", + "\u001b[0mDefaulting to user installation because normal site-packages is not writeable\n", + "Requirement already satisfied: Pillow==9.5.0 in /home/samuele/.local/lib/python3.10/site-packages (9.5.0)\n", + "\u001b[33mDEPRECATION: omegaconf 2.0.6 has a non-standard dependency specifier PyYAML>=5.1.*. pip 24.0 will enforce this behaviour change. A possible replacement is to upgrade to a newer version of omegaconf or contact the author to suggest that they release a version with a conforming dependency specifiers. Discussion can be found at https://github.com/pypa/pip/issues/12063\u001b[0m\u001b[33m\n", + "\u001b[0m" + ] + } + ], + "source": [ + "#Install and imports\n", + "!pip install torch torchvision trdg\n", + "!pip install Pillow==9.5.0\n", + "import torch\n", + "from torchvision import transforms\n", + "from PIL import Image\n", + "import matplotlib.pyplot as plt\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "78127c97-955e-46e0-869d-7f7285449f70", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Path to the image\n", + "image_path = '../static/img_1235.jpg'\n", + "\n", + "# Open the image\n", + "image = Image.open(image_path)\n", + "if image.mode != 'RGB':\n", + " image = image.convert('RGB')\n", + "\n", + "# Display the image\n", + "plt.imshow(image)\n", + "plt.axis('off') # Turn off the axis\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "bed0a320-46f3-4f84-8c51-c8cd07cea776", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Convert PIL Image to Tensor\n", + "to_tensor = transforms.ToTensor()\n", + "image = to_tensor(image)\n", + "\n", + "# Define each transformation separately\n", + "# RandomAffine: applies rotations, translations, scaling. Here, rotates by up to ±15 degrees,\n", + "affine = transforms.RandomAffine(degrees=15, translate=(0.1, 0.1), scale=(0.9, 1.1))\n", + "\n", + "# ElasticTransform: applies elastic distortions to the image. The 'alpha' parameter controls\n", + "# the intensity of the distortion.\n", + "elastic = transforms.ElasticTransform(alpha=50.0)\n", + "\n", + "# RandomPerspective: applies random perspective transformations with a specified distortion scale.\n", + "perspective = transforms.RandomPerspective(distortion_scale=0.2, p=1.0)\n", + "\n", + "# RandomErasing: randomly erases a rectangle area in the image.\n", + "erasing = transforms.RandomErasing(p=1, scale=(0.02, 0.33), ratio=(0.3, 3.3), value='random', inplace=False)\n", + "\n", + "# GaussianBlur: applies gaussian blur with specified kernel size and sigma range. \n", + "gaussian_blur = transforms.GaussianBlur(kernel_size=(5, 9), sigma=(0.4, 5))\n", + "\n", + "# A list of all transformations for iteration\n", + "transformations = [affine, elastic, perspective, erasing, gaussian_blur]\n", + "\n", + "# Vertical stacking of transformations\n", + "fig, axs = plt.subplots(len(transformations) + 1, 1, figsize=(5, 15)) \n", + "\n", + "# Permute the image dimensions from (C, H, W) to (H, W, C) for display\n", + "display_image = image.permute(1, 2, 0)\n", + "\n", + "axs[0].imshow(display_image)\n", + "axs[0].set_title('Original')\n", + "axs[0].axis('off')\n", + "\n", + "for i, transform in enumerate(transformations, 1):\n", + " augmented_image = transforms.Compose([transform])(image)\n", + " # Permute the augmented image dimensions from (C, H, W) to (H, W, C) for display\n", + " display_augmented = augmented_image.permute(1, 2, 0)\n", + "\n", + " axs[i].imshow(display_augmented)\n", + " axs[i].set_title(transform.__class__.__name__)\n", + " axs[i].axis('off')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "89c000dc-2c1e-41e6-a988-ab75819b0b39", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Path to the image\n", + "image_path = '../static/image_augmentation.png'\n", + "\n", + "# Open the image\n", + "image = Image.open(image_path)\n", + "\n", + "# Convert PIL Image to Tensor\n", + "to_tensor = transforms.ToTensor()\n", + "image_tensor = to_tensor(image)\n", + "\n", + "# Define your transformations here\n", + "affine = transforms.RandomAffine(degrees=15, translate=(0.1, 0.1), scale=(0.9, 1.1))\n", + "elastic = transforms.ElasticTransform(alpha=90.0)\n", + "perspective = transforms.RandomPerspective(distortion_scale=0.2, p=1.0)\n", + "erasing = transforms.RandomErasing(p=1, scale=(0.02, 0.33), ratio=(0.3, 3.3), value='random', inplace=False)\n", + "gaussian_blur = transforms.GaussianBlur(kernel_size=(5, 9), sigma=(0.1, 5))\n", + "\n", + "# Combine all the transformations\n", + "all_transforms = transforms.Compose([\n", + " affine,\n", + " elastic,\n", + " perspective,\n", + " erasing,\n", + " gaussian_blur\n", + "])\n", + "\n", + "# Apply combined transformation\n", + "augmented_image_tensor = all_transforms(image_tensor)\n", + "\n", + "# Set up matplotlib subplots\n", + "fig, axs = plt.subplots(1, 2, figsize=(10, 5))\n", + "\n", + "# Display original image\n", + "axs[0].imshow(image_tensor.permute(1, 2, 0)) # Change to (H, W, C) for display\n", + "axs[0].set_title('Original')\n", + "axs[0].axis('off')\n", + "\n", + "# Display augmented image\n", + "axs[1].imshow(augmented_image_tensor.permute(1, 2, 0)) # Change to (H, W, C) for display\n", + "axs[1].set_title('Transformed')\n", + "axs[1].axis('off')\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "09c1a69c-005a-41c1-8014-8fe9cb4c8ea7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Missing modules for handwritten text generation.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from trdg.generators import GeneratorFromStrings\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Define your strings\n", + "strings = ['Hello', 'This is Patrick', 'From NMA'] # Update this list as needed\n", + "\n", + "# Create a generator with the specified font\n", + "generator = GeneratorFromStrings(\n", + " strings,\n", + " space_width=2,\n", + " skewing_angle=8,\n", + " count=3, # number of images to generate\n", + " fonts=['Purisa'] # Update or add more fonts as needed\n", + ")\n", + "\n", + "# Setup matplotlib figure and display images\n", + "plt.figure(figsize=(15, 3))\n", + "for i, (text_img, lbl) in enumerate(generator, 1):\n", + " ax = plt.subplot(1, 5, i) # Adjust the number of subplots if needed\n", + " plt.imshow(text_img)\n", + " plt.title(f\"Example {i}\")\n", + " plt.axis('off')\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "29ca19de-44b0-492d-af5b-8fa78fc5e51e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.display import IFrame\n", + "\n", + "IFrame(\"https://www.calligrapher.ai/\", width=800, height=600)" + ] } ], "metadata": { diff --git a/tutorials/W1D1_Generalization/W1D1_Tutorial2.ipynb b/tutorials/W1D1_Generalization/W1D1_Tutorial2.ipynb index 0035158b3..9a64735df 100644 --- a/tutorials/W1D1_Generalization/W1D1_Tutorial2.ipynb +++ b/tutorials/W1D1_Generalization/W1D1_Tutorial2.ipynb @@ -3,379 +3,78 @@ { "cell_type": "code", "execution_count": 1, - "id": "47edb006-e23d-4909-8d3a-9782cd8763b9", + "id": "12bb9e08-6996-4d6b-8b80-a7a26191c9d6", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Defaulting to user installation because normal site-packages is not writeable\n", - "Requirement already satisfied: transformers in /home/samuele/.local/lib/python3.10/site-packages (4.36.2)\n", - "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from transformers) (3.8.0)\n", - "Requirement already satisfied: huggingface-hub<1.0,>=0.19.3 in /home/samuele/.local/lib/python3.10/site-packages (from transformers) (0.20.1)\n", - "Requirement already satisfied: numpy>=1.17 in /home/samuele/.local/lib/python3.10/site-packages (from transformers) (1.23.4)\n", - "Requirement already satisfied: packaging>=20.0 in /home/samuele/.local/lib/python3.10/site-packages (from transformers) (21.3)\n", - "Requirement already satisfied: pyyaml>=5.1 in /usr/lib/python3/dist-packages (from transformers) (5.4.1)\n", - "Requirement already satisfied: regex!=2019.12.17 in /home/samuele/.local/lib/python3.10/site-packages (from transformers) (2023.10.3)\n", - "Requirement already satisfied: requests in /home/samuele/.local/lib/python3.10/site-packages (from transformers) (2.31.0)\n", - "Requirement already satisfied: tokenizers<0.19,>=0.14 in /home/samuele/.local/lib/python3.10/site-packages (from transformers) (0.15.0)\n", - "Requirement already satisfied: safetensors>=0.3.1 in /home/samuele/.local/lib/python3.10/site-packages (from transformers) (0.4.1)\n", - "Requirement already satisfied: tqdm>=4.27 in /home/samuele/.local/lib/python3.10/site-packages (from transformers) (4.66.1)\n", - "Requirement already satisfied: fsspec>=2023.5.0 in /home/samuele/.local/lib/python3.10/site-packages (from huggingface-hub<1.0,>=0.19.3->transformers) (2023.12.2)\n", - "Requirement already satisfied: typing-extensions>=3.7.4.3 in /home/samuele/.local/lib/python3.10/site-packages (from huggingface-hub<1.0,>=0.19.3->transformers) (4.9.0)\n", - "Requirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /usr/lib/python3/dist-packages (from packaging>=20.0->transformers) (2.4.7)\n", - "Requirement already satisfied: charset-normalizer<4,>=2 in /home/samuele/.local/lib/python3.10/site-packages (from requests->transformers) (3.3.2)\n", - "Requirement already satisfied: idna<4,>=2.5 in /usr/lib/python3/dist-packages (from requests->transformers) (3.3)\n", - "Requirement already satisfied: urllib3<3,>=1.21.1 in /home/samuele/.local/lib/python3.10/site-packages (from requests->transformers) (1.26.14)\n", - "Requirement already satisfied: certifi>=2017.4.17 in /usr/lib/python3/dist-packages (from requests->transformers) (2020.6.20)\n", - "\u001b[33mDEPRECATION: omegaconf 2.0.6 has a non-standard dependency specifier PyYAML>=5.1.*. pip 24.0 will enforce this behaviour change. A possible replacement is to upgrade to a newer version of omegaconf or contact the author to suggest that they release a version with a conforming dependency specifiers. Discussion can be found at https://github.com/pypa/pip/issues/12063\u001b[0m\u001b[33m\n", - "\u001b[0m" - ] - } - ], + "outputs": [], "source": [ - "#Install transformers\n", - "!pip install transformers" + "# Imports\n", + "import scipy.io\n", + "import numpy as np\n", + "import torch\n", + "import torch.nn as nn\n", + "from torch.utils.data import TensorDataset, DataLoader\n", + "import torch.optim as optim\n", + "import os\n", + "import hashlib\n", + "import requests\n", + "from matplotlib import pyplot as plt\n", + "import tqdm as tqdm" ] }, { "cell_type": "code", "execution_count": 2, - "id": "f38a3099-2ea8-4fa6-bf3f-0fd177293d5f", + "id": "85fea2ec-e1ee-4ebe-9dff-d3b253c3ba0b", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Some weights of VisionEncoderDecoderModel were not initialized from the model checkpoint at microsoft/trocr-small-handwritten and are newly initialized: ['encoder.pooler.dense.bias', 'encoder.pooler.dense.weight']\n", - "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n" - ] - } - ], + "outputs": [], "source": [ - "#Imports\n", - "from transformers import TrOCRProcessor, VisionEncoderDecoderModel\n", + "# Variables for file and download URL\n", + "fname = \"condsForSimJ2moMuscles.mat\" # The name of the file to be downloaded\n", + "url = \"https://osf.io/wak7e/download\" # URL from where the file will be downloaded\n", + "expected_md5 = \"257d16c4d92759d615bf5cac75dd9a1f\" # MD5 hash for verifying file integrity\n", "\n", - "# Load the model\n", - "model = VisionEncoderDecoderModel.from_pretrained(\"microsoft/trocr-small-handwritten\")\n" + "# Check if the file already exists\n", + "if not os.path.isfile(fname):\n", + " try:\n", + " # Attempt to download the file\n", + " r = requests.get(url) # Make a GET request to the specified URL\n", + " except requests.ConnectionError:\n", + " # Handle connection errors during the download\n", + " print(\"!!! Failed to download data !!!\")\n", + " else:\n", + " # No connection errors, proceed to check the response\n", + " if r.status_code != requests.codes.ok:\n", + " # Check if the HTTP response status code indicates a successful download\n", + " print(\"!!! Failed to download data !!!\")\n", + " elif hashlib.md5(r.content).hexdigest() != expected_md5:\n", + " # Verify the integrity of the downloaded file using MD5 checksum\n", + " print(\"!!! Data download appears corrupted !!!\")\n", + " else:\n", + " # If download is successful and data is not corrupted, save the file\n", + " with open(fname, \"wb\") as fid:\n", + " fid.write(r.content) # Write the downloaded content to a file" ] }, { "cell_type": "code", "execution_count": 3, - "id": "52b313ee-959d-439f-bab7-02bbf631cf68", + "id": "50c15d51-8e59-4305-a2bc-e270ac349085", "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Memory usage before loading data: 316.7734375 MB\n", + "Go Envelope Tensor Trimmed Shape: torch.Size([216, 226, 1])\n", + "Plan Tensor Trimmed Shape: torch.Size([216, 226, 15])\n", + "Muscle Tensor Trimmed Shape: torch.Size([216, 226, 2])\n" + ] + }, { "data": { "text/plain": [ - "DeiTModel(\n", - " (embeddings): DeiTEmbeddings(\n", - " (patch_embeddings): DeiTPatchEmbeddings(\n", - " (projection): Conv2d(3, 384, kernel_size=(16, 16), stride=(16, 16))\n", - " )\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " (encoder): DeiTEncoder(\n", - " (layer): ModuleList(\n", - " (0): DeiTLayer(\n", - " (attention): DeiTAttention(\n", - " (attention): DeiTSelfAttention(\n", - " (query): Linear(in_features=384, out_features=384, bias=True)\n", - " (key): Linear(in_features=384, out_features=384, bias=True)\n", - " (value): Linear(in_features=384, out_features=384, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " (output): DeiTSelfOutput(\n", - " (dense): Linear(in_features=384, out_features=384, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " )\n", - " (intermediate): DeiTIntermediate(\n", - " (dense): Linear(in_features=384, out_features=1536, bias=True)\n", - " (intermediate_act_fn): GELUActivation()\n", - " )\n", - " (output): DeiTOutput(\n", - " (dense): Linear(in_features=1536, out_features=384, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " (layernorm_before): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", - " (layernorm_after): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", - " )\n", - " (1): DeiTLayer(\n", - " (attention): DeiTAttention(\n", - " (attention): DeiTSelfAttention(\n", - " (query): Linear(in_features=384, out_features=384, bias=True)\n", - " (key): Linear(in_features=384, out_features=384, bias=True)\n", - " (value): Linear(in_features=384, out_features=384, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " (output): DeiTSelfOutput(\n", - " (dense): Linear(in_features=384, out_features=384, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " )\n", - " (intermediate): DeiTIntermediate(\n", - " (dense): Linear(in_features=384, out_features=1536, bias=True)\n", - " (intermediate_act_fn): GELUActivation()\n", - " )\n", - " (output): DeiTOutput(\n", - " (dense): Linear(in_features=1536, out_features=384, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " (layernorm_before): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", - " (layernorm_after): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", - " )\n", - " (2): DeiTLayer(\n", - " (attention): DeiTAttention(\n", - " (attention): DeiTSelfAttention(\n", - " (query): Linear(in_features=384, out_features=384, bias=True)\n", - " (key): Linear(in_features=384, out_features=384, bias=True)\n", - " (value): Linear(in_features=384, out_features=384, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " (output): DeiTSelfOutput(\n", - " (dense): Linear(in_features=384, out_features=384, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " )\n", - " (intermediate): DeiTIntermediate(\n", - " (dense): Linear(in_features=384, out_features=1536, bias=True)\n", - " (intermediate_act_fn): GELUActivation()\n", - " )\n", - " (output): DeiTOutput(\n", - " (dense): Linear(in_features=1536, out_features=384, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " (layernorm_before): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", - " (layernorm_after): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", - " )\n", - " (3): DeiTLayer(\n", - " (attention): DeiTAttention(\n", - " (attention): DeiTSelfAttention(\n", - " (query): Linear(in_features=384, out_features=384, bias=True)\n", - " (key): Linear(in_features=384, out_features=384, bias=True)\n", - " (value): Linear(in_features=384, out_features=384, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " (output): DeiTSelfOutput(\n", - " (dense): Linear(in_features=384, out_features=384, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " )\n", - " (intermediate): DeiTIntermediate(\n", - " (dense): Linear(in_features=384, out_features=1536, bias=True)\n", - " (intermediate_act_fn): GELUActivation()\n", - " )\n", - " (output): DeiTOutput(\n", - " (dense): Linear(in_features=1536, out_features=384, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " (layernorm_before): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", - " (layernorm_after): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", - " )\n", - " (4): DeiTLayer(\n", - " (attention): DeiTAttention(\n", - " (attention): DeiTSelfAttention(\n", - " (query): Linear(in_features=384, out_features=384, bias=True)\n", - " (key): Linear(in_features=384, out_features=384, bias=True)\n", - " (value): Linear(in_features=384, out_features=384, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " (output): DeiTSelfOutput(\n", - " (dense): Linear(in_features=384, out_features=384, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " )\n", - " (intermediate): DeiTIntermediate(\n", - " (dense): Linear(in_features=384, out_features=1536, bias=True)\n", - " (intermediate_act_fn): GELUActivation()\n", - " )\n", - " (output): DeiTOutput(\n", - " (dense): Linear(in_features=1536, out_features=384, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " (layernorm_before): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", - " (layernorm_after): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", - " )\n", - " (5): DeiTLayer(\n", - " (attention): DeiTAttention(\n", - " (attention): DeiTSelfAttention(\n", - " (query): Linear(in_features=384, out_features=384, bias=True)\n", - " (key): Linear(in_features=384, out_features=384, bias=True)\n", - " (value): Linear(in_features=384, out_features=384, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " (output): DeiTSelfOutput(\n", - " (dense): Linear(in_features=384, out_features=384, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " )\n", - " (intermediate): DeiTIntermediate(\n", - " (dense): Linear(in_features=384, out_features=1536, bias=True)\n", - " (intermediate_act_fn): GELUActivation()\n", - " )\n", - " (output): DeiTOutput(\n", - " (dense): Linear(in_features=1536, out_features=384, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " (layernorm_before): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", - " (layernorm_after): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", - " )\n", - " (6): DeiTLayer(\n", - " (attention): DeiTAttention(\n", - " (attention): DeiTSelfAttention(\n", - " (query): Linear(in_features=384, out_features=384, bias=True)\n", - " (key): Linear(in_features=384, out_features=384, bias=True)\n", - " (value): Linear(in_features=384, out_features=384, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " (output): DeiTSelfOutput(\n", - " (dense): Linear(in_features=384, out_features=384, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " )\n", - " (intermediate): DeiTIntermediate(\n", - " (dense): Linear(in_features=384, out_features=1536, bias=True)\n", - " (intermediate_act_fn): GELUActivation()\n", - " )\n", - " (output): DeiTOutput(\n", - " (dense): Linear(in_features=1536, out_features=384, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " (layernorm_before): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", - " (layernorm_after): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", - " )\n", - " (7): DeiTLayer(\n", - " (attention): DeiTAttention(\n", - " (attention): DeiTSelfAttention(\n", - " (query): Linear(in_features=384, out_features=384, bias=True)\n", - " (key): Linear(in_features=384, out_features=384, bias=True)\n", - " (value): Linear(in_features=384, out_features=384, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " (output): DeiTSelfOutput(\n", - " (dense): Linear(in_features=384, out_features=384, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " )\n", - " (intermediate): DeiTIntermediate(\n", - " (dense): Linear(in_features=384, out_features=1536, bias=True)\n", - " (intermediate_act_fn): GELUActivation()\n", - " )\n", - " (output): DeiTOutput(\n", - " (dense): Linear(in_features=1536, out_features=384, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " (layernorm_before): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", - " (layernorm_after): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", - " )\n", - " (8): DeiTLayer(\n", - " (attention): DeiTAttention(\n", - " (attention): DeiTSelfAttention(\n", - " (query): Linear(in_features=384, out_features=384, bias=True)\n", - " (key): Linear(in_features=384, out_features=384, bias=True)\n", - " (value): Linear(in_features=384, out_features=384, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " (output): DeiTSelfOutput(\n", - " (dense): Linear(in_features=384, out_features=384, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " )\n", - " (intermediate): DeiTIntermediate(\n", - " (dense): Linear(in_features=384, out_features=1536, bias=True)\n", - " (intermediate_act_fn): GELUActivation()\n", - " )\n", - " (output): DeiTOutput(\n", - " (dense): Linear(in_features=1536, out_features=384, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " (layernorm_before): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", - " (layernorm_after): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", - " )\n", - " (9): DeiTLayer(\n", - " (attention): DeiTAttention(\n", - " (attention): DeiTSelfAttention(\n", - " (query): Linear(in_features=384, out_features=384, bias=True)\n", - " (key): Linear(in_features=384, out_features=384, bias=True)\n", - " (value): Linear(in_features=384, out_features=384, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " (output): DeiTSelfOutput(\n", - " (dense): Linear(in_features=384, out_features=384, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " )\n", - " (intermediate): DeiTIntermediate(\n", - " (dense): Linear(in_features=384, out_features=1536, bias=True)\n", - " (intermediate_act_fn): GELUActivation()\n", - " )\n", - " (output): DeiTOutput(\n", - " (dense): Linear(in_features=1536, out_features=384, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " (layernorm_before): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", - " (layernorm_after): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", - " )\n", - " (10): DeiTLayer(\n", - " (attention): DeiTAttention(\n", - " (attention): DeiTSelfAttention(\n", - " (query): Linear(in_features=384, out_features=384, bias=True)\n", - " (key): Linear(in_features=384, out_features=384, bias=True)\n", - " (value): Linear(in_features=384, out_features=384, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " (output): DeiTSelfOutput(\n", - " (dense): Linear(in_features=384, out_features=384, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " )\n", - " (intermediate): DeiTIntermediate(\n", - " (dense): Linear(in_features=384, out_features=1536, bias=True)\n", - " (intermediate_act_fn): GELUActivation()\n", - " )\n", - " (output): DeiTOutput(\n", - " (dense): Linear(in_features=1536, out_features=384, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " (layernorm_before): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", - " (layernorm_after): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", - " )\n", - " (11): DeiTLayer(\n", - " (attention): DeiTAttention(\n", - " (attention): DeiTSelfAttention(\n", - " (query): Linear(in_features=384, out_features=384, bias=True)\n", - " (key): Linear(in_features=384, out_features=384, bias=True)\n", - " (value): Linear(in_features=384, out_features=384, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " (output): DeiTSelfOutput(\n", - " (dense): Linear(in_features=384, out_features=384, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " )\n", - " (intermediate): DeiTIntermediate(\n", - " (dense): Linear(in_features=384, out_features=1536, bias=True)\n", - " (intermediate_act_fn): GELUActivation()\n", - " )\n", - " (output): DeiTOutput(\n", - " (dense): Linear(in_features=1536, out_features=384, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " (layernorm_before): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", - " (layernorm_after): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", - " )\n", - " )\n", - " )\n", - " (layernorm): LayerNorm((384,), eps=1e-12, elementwise_affine=True)\n", - " (pooler): DeiTPooler(\n", - " (dense): Linear(in_features=384, out_features=384, bias=True)\n", - " (activation): Tanh()\n", - " )\n", - ")" + "0" ] }, "execution_count": 3, @@ -384,215 +83,877 @@ } ], "source": [ - "# Inspect the encoder of the model\n", - "model.encoder\n" + "# Before loading data, check memory usage\n", + "import psutil\n", + "print(f'Memory usage before loading data: {psutil.Process(os.getpid()).memory_info().rss / (1024 * 1024)} MB')\n", + "\n", + "# Load the .mat file\n", + "data = scipy.io.loadmat('condsForSimJ2moMuscles.mat')\n", + "\n", + "# Extract condsForSim struct\n", + "conds_for_sim = data['condsForSim']\n", + "\n", + "# Initialize lists to store data for all conditions\n", + "go_envelope_all = []\n", + "plan_all = []\n", + "muscle_all = []\n", + "\n", + "# Get the number of conditions (rows) and delay durations (columns)\n", + "num_conditions, num_delays = conds_for_sim.shape\n", + "\n", + "# Loop through each condition and extract data\n", + "for i in range(num_conditions): # 27 conditions\n", + " go_envelope_condition = []\n", + " plan_condition = []\n", + " muscle_condition = []\n", + "\n", + " for j in range(num_delays): # 8 delay durations\n", + " condition = conds_for_sim[i, j]\n", + "\n", + " go_envelope = condition['goEnvelope']\n", + " plan = condition['plan']\n", + " muscle = condition['muscle']\n", + "\n", + " # Select only muscles 5 and 6 \n", + " selected_muscle_data = muscle[:, [3, 4]] # which show the nicest multiphasic activity\n", + "\n", + " go_envelope_condition.append(go_envelope)\n", + " plan_condition.append(plan)\n", + " muscle_condition.append(selected_muscle_data)\n", + "\n", + " # Convert lists of NumPy arrays to single NumPy arrays before conversion to tensors\n", + " go_envelope_np = np.array(go_envelope_condition)\n", + " plan_np = np.array(plan_condition)\n", + " muscle_np = np.array(muscle_condition)\n", + "\n", + " # Convert the single NumPy arrays to PyTorch tensors\n", + " go_envelope_all.append(torch.tensor(go_envelope_np, dtype=torch.float32))\n", + " plan_all.append(torch.tensor(plan_np, dtype=torch.float32))\n", + " muscle_all.append(torch.tensor(muscle_np, dtype=torch.float32))\n", + "\n", + "# Stack data for all conditions\n", + "go_envelope_tensor = torch.stack(go_envelope_all)\n", + "plan_tensor = torch.stack(plan_all)\n", + "muscle_tensor = torch.stack(muscle_all)\n", + "\n", + "# Reshape to merge the first two dimensions\n", + "go_envelope_tensor = go_envelope_tensor.reshape(-1, *go_envelope_tensor.shape[2:])\n", + "plan_tensor = plan_tensor.reshape(-1, *plan_tensor.shape[2:])\n", + "muscle_tensor = muscle_tensor.reshape(-1, *muscle_tensor.shape[2:])\n", + "\n", + "# Remove the first 70 time steps\n", + "go_envelope_tensor = go_envelope_tensor[:, 70:, :]\n", + "plan_tensor = plan_tensor[:, 70:, :]\n", + "muscle_tensor = muscle_tensor[:, 70:, :]\n", + "\n", + "# Let's print the new shapes to confirm the change\n", + "print(f'Go Envelope Tensor Trimmed Shape: {go_envelope_tensor.shape}')\n", + "print(f'Plan Tensor Trimmed Shape: {plan_tensor.shape}')\n", + "print(f'Muscle Tensor Trimmed Shape: {muscle_tensor.shape}')\n", + "\n", + "# After tensors are created, we no longer need `data` and `conds_for_sim`\n", + "del data\n", + "del conds_for_sim\n", + "# After tensors are reshaped and you no longer need the original ones\n", + "del go_envelope_all\n", + "del plan_all\n", + "del muscle_all\n", + "del go_envelope_np\n", + "del plan_np\n", + "del muscle_np\n", + "\n", + "import gc\n", + "gc.collect()" ] }, { "cell_type": "code", "execution_count": 4, - "id": "f945ff0c-6d1f-446a-8975-04f5821fca90", + "id": "417463ca-29c8-4229-baed-58dcf390747a", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "TrOCRForCausalLM(\n", - " (model): TrOCRDecoderWrapper(\n", - " (decoder): TrOCRDecoder(\n", - " (embed_tokens): Embedding(64044, 256, padding_idx=1)\n", - " (embed_positions): TrOCRLearnedPositionalEmbedding(514, 256)\n", - " (layernorm_embedding): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", - " (layers): ModuleList(\n", - " (0): TrOCRDecoderLayer(\n", - " (self_attn): TrOCRAttention(\n", - " (k_proj): Linear(in_features=256, out_features=256, bias=True)\n", - " (v_proj): Linear(in_features=256, out_features=256, bias=True)\n", - " (q_proj): Linear(in_features=256, out_features=256, bias=True)\n", - " (out_proj): Linear(in_features=256, out_features=256, bias=True)\n", - " )\n", - " (activation_fn): ReLU()\n", - " (self_attn_layer_norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", - " (encoder_attn): TrOCRAttention(\n", - " (k_proj): Linear(in_features=384, out_features=256, bias=True)\n", - " (v_proj): Linear(in_features=384, out_features=256, bias=True)\n", - " (q_proj): Linear(in_features=256, out_features=256, bias=True)\n", - " (out_proj): Linear(in_features=256, out_features=256, bias=True)\n", - " )\n", - " (encoder_attn_layer_norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", - " (fc1): Linear(in_features=256, out_features=1024, bias=True)\n", - " (fc2): Linear(in_features=1024, out_features=256, bias=True)\n", - " (final_layer_norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", - " )\n", - " (1): TrOCRDecoderLayer(\n", - " (self_attn): TrOCRAttention(\n", - " (k_proj): Linear(in_features=256, out_features=256, bias=True)\n", - " (v_proj): Linear(in_features=256, out_features=256, bias=True)\n", - " (q_proj): Linear(in_features=256, out_features=256, bias=True)\n", - " (out_proj): Linear(in_features=256, out_features=256, bias=True)\n", - " )\n", - " (activation_fn): ReLU()\n", - " (self_attn_layer_norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", - " (encoder_attn): TrOCRAttention(\n", - " (k_proj): Linear(in_features=384, out_features=256, bias=True)\n", - " (v_proj): Linear(in_features=384, out_features=256, bias=True)\n", - " (q_proj): Linear(in_features=256, out_features=256, bias=True)\n", - " (out_proj): Linear(in_features=256, out_features=256, bias=True)\n", - " )\n", - " (encoder_attn_layer_norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", - " (fc1): Linear(in_features=256, out_features=1024, bias=True)\n", - " (fc2): Linear(in_features=1024, out_features=256, bias=True)\n", - " (final_layer_norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", - " )\n", - " (2): TrOCRDecoderLayer(\n", - " (self_attn): TrOCRAttention(\n", - " (k_proj): Linear(in_features=256, out_features=256, bias=True)\n", - " (v_proj): Linear(in_features=256, out_features=256, bias=True)\n", - " (q_proj): Linear(in_features=256, out_features=256, bias=True)\n", - " (out_proj): Linear(in_features=256, out_features=256, bias=True)\n", - " )\n", - " (activation_fn): ReLU()\n", - " (self_attn_layer_norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", - " (encoder_attn): TrOCRAttention(\n", - " (k_proj): Linear(in_features=384, out_features=256, bias=True)\n", - " (v_proj): Linear(in_features=384, out_features=256, bias=True)\n", - " (q_proj): Linear(in_features=256, out_features=256, bias=True)\n", - " (out_proj): Linear(in_features=256, out_features=256, bias=True)\n", - " )\n", - " (encoder_attn_layer_norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", - " (fc1): Linear(in_features=256, out_features=1024, bias=True)\n", - " (fc2): Linear(in_features=1024, out_features=256, bias=True)\n", - " (final_layer_norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", - " )\n", - " (3): TrOCRDecoderLayer(\n", - " (self_attn): TrOCRAttention(\n", - " (k_proj): Linear(in_features=256, out_features=256, bias=True)\n", - " (v_proj): Linear(in_features=256, out_features=256, bias=True)\n", - " (q_proj): Linear(in_features=256, out_features=256, bias=True)\n", - " (out_proj): Linear(in_features=256, out_features=256, bias=True)\n", - " )\n", - " (activation_fn): ReLU()\n", - " (self_attn_layer_norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", - " (encoder_attn): TrOCRAttention(\n", - " (k_proj): Linear(in_features=384, out_features=256, bias=True)\n", - " (v_proj): Linear(in_features=384, out_features=256, bias=True)\n", - " (q_proj): Linear(in_features=256, out_features=256, bias=True)\n", - " (out_proj): Linear(in_features=256, out_features=256, bias=True)\n", - " )\n", - " (encoder_attn_layer_norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", - " (fc1): Linear(in_features=256, out_features=1024, bias=True)\n", - " (fc2): Linear(in_features=1024, out_features=256, bias=True)\n", - " (final_layer_norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", - " )\n", - " (4): TrOCRDecoderLayer(\n", - " (self_attn): TrOCRAttention(\n", - " (k_proj): Linear(in_features=256, out_features=256, bias=True)\n", - " (v_proj): Linear(in_features=256, out_features=256, bias=True)\n", - " (q_proj): Linear(in_features=256, out_features=256, bias=True)\n", - " (out_proj): Linear(in_features=256, out_features=256, bias=True)\n", - " )\n", - " (activation_fn): ReLU()\n", - " (self_attn_layer_norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", - " (encoder_attn): TrOCRAttention(\n", - " (k_proj): Linear(in_features=384, out_features=256, bias=True)\n", - " (v_proj): Linear(in_features=384, out_features=256, bias=True)\n", - " (q_proj): Linear(in_features=256, out_features=256, bias=True)\n", - " (out_proj): Linear(in_features=256, out_features=256, bias=True)\n", - " )\n", - " (encoder_attn_layer_norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", - " (fc1): Linear(in_features=256, out_features=1024, bias=True)\n", - " (fc2): Linear(in_features=1024, out_features=256, bias=True)\n", - " (final_layer_norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", - " )\n", - " (5): TrOCRDecoderLayer(\n", - " (self_attn): TrOCRAttention(\n", - " (k_proj): Linear(in_features=256, out_features=256, bias=True)\n", - " (v_proj): Linear(in_features=256, out_features=256, bias=True)\n", - " (q_proj): Linear(in_features=256, out_features=256, bias=True)\n", - " (out_proj): Linear(in_features=256, out_features=256, bias=True)\n", - " )\n", - " (activation_fn): ReLU()\n", - " (self_attn_layer_norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", - " (encoder_attn): TrOCRAttention(\n", - " (k_proj): Linear(in_features=384, out_features=256, bias=True)\n", - " (v_proj): Linear(in_features=384, out_features=256, bias=True)\n", - " (q_proj): Linear(in_features=256, out_features=256, bias=True)\n", - " (out_proj): Linear(in_features=256, out_features=256, bias=True)\n", - " )\n", - " (encoder_attn_layer_norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", - " (fc1): Linear(in_features=256, out_features=1024, bias=True)\n", - " (fc2): Linear(in_features=1024, out_features=256, bias=True)\n", - " (final_layer_norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", - " )\n", - " )\n", - " )\n", - " )\n", - " (output_projection): Linear(in_features=256, out_features=64044, bias=False)\n", - ")" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "# Inspect the decoder of the model\n", - "model.decoder" + "# Normalization and Standardization\n", + "def normalize_and_standardize(tensor):\n", + "\n", + " # Standardize: shift to zero mean and unit variance\n", + " mean = tensor.mean()\n", + " std = tensor.std()\n", + " tensor = (tensor - mean) / std\n", + "\n", + " return tensor\n", + "\n", + "# Apply normalization and standardization to go_envelope_tensor and plan_tensor\n", + "normalized_go_envelope_tensor = normalize_and_standardize(go_envelope_tensor)\n", + "normalized_plan_tensor = normalize_and_standardize(plan_tensor)\n", + "normalized_muscle_tensor = muscle_tensor\n", + "\n", + "# Concatenate normalized tensors along the last dimension\n", + "X_train = torch.cat((normalized_go_envelope_tensor, normalized_plan_tensor), dim=2)\n", + "y_train = normalized_muscle_tensor\n", + "\n", + "batch_size = 256 # You can adjust this based on your data size and memory constraints\n", + "train_data = TensorDataset(X_train, y_train)\n", + "train_loader = DataLoader(train_data, batch_size=batch_size, shuffle=False)" ] }, { "cell_type": "code", - "execution_count": 5, - "id": "ae53ffa9-2f29-4042-9786-6d5537e7a8f3", + "execution_count": null, + "id": "7e2b6a95-49a0-4f10-8f63-3b85a7f7d7be", "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "(21960192, 39636480)" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1, Loss: 0.5519322156906128\n", + "Epoch 2, Loss: 0.4986596703529358\n", + "Epoch 3, Loss: 0.4689335823059082\n", + "Epoch 4, Loss: 0.4492972493171692\n", + "Epoch 5, Loss: 0.4316917061805725\n", + "Epoch 6, Loss: 0.41479480266571045\n", + "Epoch 7, Loss: 0.398833304643631\n", + "Epoch 8, Loss: 0.3844679594039917\n", + "Epoch 9, Loss: 0.3721160590648651\n", + "Epoch 10, Loss: 0.36075031757354736\n", + "Epoch 11, Loss: 0.3493914306163788\n", + "Epoch 12, Loss: 0.33835771679878235\n", + "Epoch 13, Loss: 0.32839053869247437\n", + "Epoch 14, Loss: 0.31947383284568787\n", + "Epoch 15, Loss: 0.3110644817352295\n", + "Epoch 16, Loss: 0.3029980957508087\n", + "Epoch 17, Loss: 0.29531052708625793\n", + "Epoch 18, Loss: 0.287977933883667\n", + "Epoch 19, Loss: 0.2811145782470703\n", + "Epoch 20, Loss: 0.2747448980808258\n", + "Epoch 21, Loss: 0.26856422424316406\n", + "Epoch 22, Loss: 0.2624956965446472\n", + "Epoch 23, Loss: 0.2566568851470947\n", + "Epoch 24, Loss: 0.25110575556755066\n", + "Epoch 25, Loss: 0.2458736151456833\n", + "Epoch 26, Loss: 0.24088245630264282\n", + "Epoch 27, Loss: 0.2360183298587799\n", + "Epoch 28, Loss: 0.2313256710767746\n", + "Epoch 29, Loss: 0.22685857117176056\n", + "Epoch 30, Loss: 0.2225888967514038\n", + "Epoch 31, Loss: 0.21851670742034912\n", + "Epoch 32, Loss: 0.2145949900150299\n", + "Epoch 33, Loss: 0.21078437566757202\n", + "Epoch 34, Loss: 0.20711404085159302\n", + "Epoch 35, Loss: 0.20359206199645996\n", + "Epoch 36, Loss: 0.20020133256912231\n", + "Epoch 37, Loss: 0.1969325840473175\n", + "Epoch 38, Loss: 0.19376400113105774\n", + "Epoch 39, Loss: 0.19071149826049805\n", + "Epoch 40, Loss: 0.18777306377887726\n", + "Epoch 41, Loss: 0.18495255708694458\n", + "Epoch 42, Loss: 0.18222197890281677\n", + "Epoch 43, Loss: 0.1795603632926941\n", + "Epoch 44, Loss: 0.17696455121040344\n", + "Epoch 45, Loss: 0.17446495592594147\n", + "Epoch 46, Loss: 0.1720551699399948\n", + "Epoch 47, Loss: 0.16972263157367706\n", + "Epoch 48, Loss: 0.1674545854330063\n", + "Epoch 49, Loss: 0.1652541160583496\n", + "Epoch 50, Loss: 0.1631237417459488\n", + "Epoch 51, Loss: 0.1610482931137085\n", + "Epoch 52, Loss: 0.15902777016162872\n", + "Epoch 53, Loss: 0.15706560015678406\n", + "Epoch 54, Loss: 0.15515753626823425\n", + "Epoch 55, Loss: 0.15330243110656738\n", + "Epoch 56, Loss: 0.151495099067688\n", + "Epoch 57, Loss: 0.1497366726398468\n", + "Epoch 58, Loss: 0.14803031086921692\n", + "Epoch 59, Loss: 0.14636950194835663\n", + "Epoch 60, Loss: 0.14475306868553162\n", + "Epoch 61, Loss: 0.14318086206912994\n", + "Epoch 62, Loss: 0.1416507065296173\n", + "Epoch 63, Loss: 0.14015871286392212\n", + "Epoch 64, Loss: 0.13870401680469513\n", + "Epoch 65, Loss: 0.13728773593902588\n", + "Epoch 66, Loss: 0.1359080821275711\n", + "Epoch 67, Loss: 0.13456253707408905\n", + "Epoch 68, Loss: 0.1332491934299469\n", + "Epoch 69, Loss: 0.13196663558483124\n", + "Epoch 70, Loss: 0.13071230053901672\n", + "Epoch 71, Loss: 0.12948517501354218\n", + "Epoch 72, Loss: 0.1282859593629837\n", + "Epoch 73, Loss: 0.12711575627326965\n", + "Epoch 74, Loss: 0.12597249448299408\n", + "Epoch 75, Loss: 0.12485451996326447\n", + "Epoch 76, Loss: 0.12376077473163605\n", + "Epoch 77, Loss: 0.12269100546836853\n", + "Epoch 78, Loss: 0.12164456397294998\n", + "Epoch 79, Loss: 0.12062013894319534\n", + "Epoch 80, Loss: 0.11961705982685089\n", + "Epoch 81, Loss: 0.118634894490242\n", + "Epoch 82, Loss: 0.1176738515496254\n", + "Epoch 83, Loss: 0.11673554033041\n", + "Epoch 84, Loss: 0.11582382023334503\n", + "Epoch 85, Loss: 0.11495845764875412\n", + "Epoch 86, Loss: 0.1142244040966034\n", + "Epoch 87, Loss: 0.11365008354187012\n", + "Epoch 88, Loss: 0.1128997877240181\n", + "Epoch 89, Loss: 0.11157360672950745\n", + "Epoch 90, Loss: 0.11110398918390274\n", + "Epoch 91, Loss: 0.11017798632383347\n", + "Epoch 92, Loss: 0.10941486060619354\n", + "Epoch 93, Loss: 0.10868389159440994\n", + "Epoch 94, Loss: 0.1078869104385376\n", + "Epoch 95, Loss: 0.10722575336694717\n", + "Epoch 96, Loss: 0.10645269602537155\n", + "Epoch 97, Loss: 0.1058158203959465\n", + "Epoch 98, Loss: 0.10506423562765121\n", + "Epoch 99, Loss: 0.1044677197933197\n", + "Epoch 100, Loss: 0.10373218357563019\n", + "Epoch 101, Loss: 0.1031772643327713\n", + "Epoch 102, Loss: 0.1024479940533638\n", + "Epoch 103, Loss: 0.10191866010427475\n", + "Epoch 104, Loss: 0.10122103989124298\n", + "Epoch 105, Loss: 0.10069246590137482\n", + "Epoch 106, Loss: 0.1000451147556305\n", + "Epoch 107, Loss: 0.09949776530265808\n", + "Epoch 108, Loss: 0.09891969710588455\n", + "Epoch 109, Loss: 0.09834467619657516\n", + "Epoch 110, Loss: 0.09782713651657104\n", + "Epoch 111, Loss: 0.0972403809428215\n", + "Epoch 112, Loss: 0.09674455970525742\n", + "Epoch 113, Loss: 0.0961964875459671\n", + "Epoch 114, Loss: 0.09567713737487793\n", + "Epoch 115, Loss: 0.09519167244434357\n", + "Epoch 116, Loss: 0.09466236084699631\n", + "Epoch 117, Loss: 0.09418143332004547\n", + "Epoch 118, Loss: 0.09371201694011688\n", + "Epoch 119, Loss: 0.09320862591266632\n", + "Epoch 120, Loss: 0.0927414745092392\n", + "Epoch 121, Loss: 0.09229478985071182\n", + "Epoch 122, Loss: 0.09182220697402954\n", + "Epoch 123, Loss: 0.09135950356721878\n", + "Epoch 124, Loss: 0.09092652797698975\n", + "Epoch 125, Loss: 0.09049703925848007\n", + "Epoch 126, Loss: 0.09005860984325409\n", + "Epoch 127, Loss: 0.08961967378854752\n", + "Epoch 128, Loss: 0.08919590711593628\n", + "Epoch 129, Loss: 0.08878778666257858\n", + "Epoch 130, Loss: 0.08839017897844315\n", + "Epoch 131, Loss: 0.08800011873245239\n", + "Epoch 132, Loss: 0.08761876076459885\n", + "Epoch 133, Loss: 0.08724765479564667\n", + "Epoch 134, Loss: 0.0868886411190033\n", + "Epoch 135, Loss: 0.08651196956634521\n", + "Epoch 136, Loss: 0.08610555529594421\n", + "Epoch 137, Loss: 0.08568298816680908\n", + "Epoch 138, Loss: 0.08531112223863602\n", + "Epoch 139, Loss: 0.0849844291806221\n", + "Epoch 140, Loss: 0.08464300632476807\n", + "Epoch 141, Loss: 0.0842752680182457\n", + "Epoch 142, Loss: 0.08389715850353241\n", + "Epoch 143, Loss: 0.08354433625936508\n", + "Epoch 144, Loss: 0.08321848511695862\n", + "Epoch 145, Loss: 0.08290661871433258\n", + "Epoch 146, Loss: 0.08260558545589447\n", + "Epoch 147, Loss: 0.08230576664209366\n", + "Epoch 148, Loss: 0.08200815320014954\n", + "Epoch 149, Loss: 0.08167603611946106\n", + "Epoch 150, Loss: 0.08131074905395508\n", + "Epoch 151, Loss: 0.08095855265855789\n", + "Epoch 152, Loss: 0.08067390322685242\n", + "Epoch 153, Loss: 0.08040428161621094\n", + "Epoch 154, Loss: 0.08009021729230881\n", + "Epoch 155, Loss: 0.07976528257131577\n", + "Epoch 156, Loss: 0.07945775985717773\n", + "Epoch 157, Loss: 0.07918529957532883\n", + "Epoch 158, Loss: 0.0789315477013588\n", + "Epoch 159, Loss: 0.07867088168859482\n", + "Epoch 160, Loss: 0.07842285931110382\n", + "Epoch 161, Loss: 0.07815377414226532\n", + "Epoch 162, Loss: 0.07786113023757935\n" + ] } ], "source": [ - "# Function to count the parameters of the model\n", - "def count_parameters(model):\n", - " return sum(p.numel() for p in model.parameters())\n", + "# Define a custom Rectified Tanh activation function\n", + "def rectified_tanh(x):\n", + " return torch.where(x > 0, torch.tanh(x), 0) # was torch.where(x > 0, x, torch.tanh(x))\n", + "def grad_rectified_tanh(x):\n", + " return torch.where(x > 0, 1 - torch.tanh(x)**2, 0)\n", + "def grad_tanh(x):\n", + " return 1 - torch.tanh(x)**2\n", + " \n", + "class SimpleRNN(nn.Module):\n", + " def __init__(self, input_size, hidden_size, output_size, g, h, tau=50):\n", + " super(SimpleRNN, self).__init__()\n", + " self.hidden_size = hidden_size\n", + " self.tau = tau # Time constant\n", + " self.output_linear = nn.Linear(hidden_size, output_size) # New linear layer\n", + "\n", + " # Weight initialization\n", + " self.J = nn.Parameter(torch.randn(hidden_size, hidden_size) * (g / torch.sqrt(torch.tensor(hidden_size, dtype=torch.float))))\n", + " self.B = nn.Parameter(torch.randn(hidden_size, input_size) * (h / torch.sqrt(torch.tensor(input_size, dtype=torch.float)))) \n", + " self.bx = nn.Parameter(torch.zeros(hidden_size))\n", + "\n", + " # Nonlinearity\n", + " self.nonlinearity = rectified_tanh \n", + " \n", + " self.hidden_activations = [] \n", + " \n", + " def forward(self, x, hidden):\n", + " hidden_prev = hidden.clone()\n", + " timestep = self.tau / 10 # Timestep for Euler integration \n", + " # Update hidden state\n", + " firing_rate = self.nonlinearity(hidden) \n", + " hidden_update = torch.matmul(self.J, firing_rate.transpose(0, 1)) \n", + " input_update = torch.matmul(self.B, x.transpose(0, 1)) \n", + " new_hidden = hidden_update + input_update + self.bx.unsqueeze(1)\n", + " new_hidden = new_hidden.transpose(0, 1) \n", + " # Euler integration for continuous-time update\n", + " hidden = hidden + (timestep / self.tau) * (-hidden_prev + new_hidden) \n", + " # Output calculation\n", + " output = self.output_linear(firing_rate) \n", + " # Regularization terms\n", + " firing_rate_reg = hidden.pow(2).sum()\n", + " dynamic_reg = torch.linalg.norm(torch.matmul(self.J, grad_rectified_tanh(hidden.transpose(0, 1))), ord='fro', dim=(-2, -1)).sum()\n", + " \n", + " self.hidden_activations.append(hidden.clone())\n", + " \n", + " return output, hidden, firing_rate_reg, dynamic_reg\n", "\n", - "# Count parameters in the encoder\n", - "encoder_params = count_parameters(model.encoder)\n", + " def reset_activations(self):\n", + " self.hidden_activations = []\n", + " \n", + " def init_hidden(self, batch_size):\n", + " # Initialize hidden state with batch dimension\n", + " return torch.zeros(batch_size, self.hidden_size)\n", "\n", - "# Count parameters in the decoder\n", - "decoder_params = count_parameters(model.decoder)\n", + "def compute_l2_regularization(parameters, alpha):\n", + " l2_reg = sum(p.pow(2.0).sum() for p in parameters)\n", + " return alpha * l2_reg\n", "\n", - "encoder_params, decoder_params\n" + "# Hyperparameters\n", + "input_size = 16\n", + "hidden_size = 150\n", + "output_size = 2 # Number of muscles\n", + "g = 1.5 # g value\n", + "h_val = 1.0 # h value\n", + "\n", + "# Hyperparameters for regularization\n", + "alpha = 1e-4 \n", + "beta = 0.03\n", + "gamma = 1e-4\n", + "\n", + "# Training Loop\n", + "num_epochs = 500\n", + "epoch_losses = [] \n", + "\n", + "# get available device\n", + "if torch.backends.mps.is_available():\n", + " device = torch.device('mps')\n", + "elif torch.cuda.is_available():\n", + " device = torch.device('cuda')\n", + "else:\n", + " device = torch.device('cpu')\n", + "\n", + "# Model instantiation\n", + "model = SimpleRNN(input_size, hidden_size, output_size, g, h_val)\n", + "model.to(device)\n", + "hidden_states_for_plot = []\n", + "# Loss Function and Optimizer\n", + "criterion = nn.MSELoss() # MSE Loss for regression tasks\n", + "optimizer = optim.Adam(model.parameters(), lr=0.001, weight_decay=0) ### WD=0. Note: Paper uses Hessian-Free optimizer\n", + "\n", + "for epoch in range(num_epochs):\n", + " running_loss = 0.0\n", + " for inputs, targets in train_loader:\n", + " inputs, targets = inputs.to(device), targets.to(device)\n", + " batch_size = inputs.size(0)\n", + " h = model.init_hidden(batch_size).to(device) # Initialize hidden state with the current batch size\n", + " optimizer.zero_grad()\n", + "\n", + " total_firing_rate_reg = 0\n", + " total_dynamic_reg = 0\n", + "\n", + " for t in range(inputs.shape[1]): # Iterate over time steps\n", + " output, h, firing_rate_reg, dynamic_reg = model(inputs[:, t, :], h)\n", + " hidden_states_for_plot.append(h.detach().cpu().numpy())\n", + " total_firing_rate_reg += firing_rate_reg\n", + " total_dynamic_reg += dynamic_reg\n", + " # Clear memory of intermediate tensors\n", + " del firing_rate_reg, dynamic_reg\n", + " torch.cuda.empty_cache()\n", + " gc.collect()\n", + "\n", + " # Compute loss using the last output and include regularization terms\n", + " loss = criterion(output, targets[:, -1, :])\n", + " l2_reg = compute_l2_regularization(model.parameters(), alpha)\n", + " rfr_reg = beta * total_firing_rate_reg / inputs.shape[1] / hidden_size /num_conditions # Average over time steps\n", + " rj_reg = gamma * total_firing_rate_reg / inputs.shape[1] /num_conditions # Average over time steps\n", + " \n", + " total_loss = loss + l2_reg + rfr_reg + rj_reg\n", + "\n", + " total_loss.backward()\n", + " torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1)\n", + " optimizer.step()\n", + " \n", + " running_loss += total_loss.item()\n", + "\n", + " # Clear memory at the end of each batch\n", + " del inputs, targets, h\n", + "\n", + " avg_loss = running_loss / float(len(train_loader))\n", + " epoch_losses.append(avg_loss)\n", + " print(f'Epoch {epoch + 1}, Loss: {avg_loss}')\n", + "\n", + "\n", + " torch.cuda.empty_cache()\n", + " gc.collect()\n", + "\n", + "print('Finished Training')\n", + "\n", + "# Clear cache after training\n", + "if device.type == 'cuda':\n", + " torch.cuda.empty_cache()\n", + " \n", + "# Monitor memory usage after training\n", + "print(f'Memory usage after training: {psutil.Process(os.getpid()).memory_info().rss / (1024 * 1024)} MB') \n", + "\n", + "# Plotting\n", + "plt.figure(figsize=(10, 6))\n", + "plt.plot(range(1, num_epochs + 1), epoch_losses, label='Training Loss')\n", + "plt.xlabel('Epoch')\n", + "plt.ylabel('Loss')\n", + "plt.title('Training Loss Over Epochs')\n", + "plt.legend()\n", + "plt.show()" ] }, { "cell_type": "code", - "execution_count": 6, - "id": "6e9cd211-aa80-4d0f-a272-2452e78b8cae", + "execution_count": null, + "id": "21dd9a5b-0e80-4464-aa8e-9ec54d225646", "metadata": {}, "outputs": [], "source": [ - "#Look at the available variants of this model (i.e. small, base, large). \n", - "#How do these models trade off in terms of accuracy vs. inference latency?\n", + "import torch\n", + "import torch.nn as nn\n", + "import torch.optim as optim\n", + "\n", + "# Custom activation function (remains unchanged)\n", + "def rectified_tanh(x):\n", + " return torch.where(x > 0, torch.tanh(x), 0)\n", + "\n", + "# ComplicatedRNN class\n", + "class ComplicatedRNN(nn.Module):\n", + " def __init__(self, input_size, hidden_size, output_size, g, h, tau=50):\n", + " super(ComplicatedRNN, self).__init__()\n", + " self.hidden_size = hidden_size\n", + " self.tau = tau\n", + " self.output_linear = nn.Linear(hidden_size, output_size)\n", + "\n", + " # Weight initialization (unchanged)\n", + " self.J = nn.Parameter(torch.randn(hidden_size, hidden_size) * (g / torch.sqrt(torch.tensor(hidden_size, dtype=torch.float))))\n", + " self.B = nn.Parameter(torch.randn(hidden_size, input_size) * (h / torch.sqrt(torch.tensor(input_size, dtype=torch.float)))) \n", + " self.bx = nn.Parameter(torch.zeros(hidden_size))\n", + "\n", + " # Nonlinearity (unchanged)\n", + " self.nonlinearity = rectified_tanh \n", + " \n", + " self.hidden_activations = [] \n", + "\n", + " def forward(self, x, hidden):\n", + " # Forward pass logic (same as SimpleRNN but without regularization terms)\n", + " hidden_prev = hidden.clone()\n", + " timestep = self.tau / 10\n", + "\n", + " firing_rate = self.nonlinearity(hidden)\n", + " \n", + " hidden_update = torch.matmul(self.J, firing_rate.transpose(0, 1))\n", + " input_update = torch.matmul(self.B, x.transpose(0, 1))\n", + " \n", + " new_hidden = hidden_update + input_update + self.bx.unsqueeze(1)\n", + " new_hidden = new_hidden.transpose(0, 1)\n", + " \n", + " hidden = hidden + (timestep / self.tau) * (-hidden_prev + new_hidden)\n", + " output = self.output_linear(firing_rate)\n", + " \n", + " self.hidden_activations.append(hidden.clone())\n", + "\n", + " return output, hidden\n", + " \n", + " def reset_activations(self):\n", + " self.hidden_activations = []\n", + " \n", + " def init_hidden(self, batch_size):\n", + " return torch.zeros(batch_size, self.hidden_size)\n", + "\n", + "# Training loop\n", + "# Hyperparameters \n", + "input_size = 16\n", + "hidden_size = 150\n", + "output_size = 2\n", + "g = 4\n", + "h_val = 1.0\n", + "num_epochs = 500\n", + "epoch_losses = []\n", + "\n", + "# Device setup and model instantiation \n", + "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "complicated_model = ComplicatedRNN(input_size, hidden_size, output_size, g, h_val)\n", + "complicated_model.to(device)\n", + "hidden_states_for_plot_cm = []\n", + "\n", + "# Loss function and optimizer (no weight decay)\n", + "criterion = nn.MSELoss()\n", + "optimizer = optim.Adam(complicated_model.parameters(), lr=0.001)\n", + "\n", + "# Training loop (updated to remove regularization terms)\n", + "for epoch in range(num_epochs):\n", + " running_loss = 0.0\n", + " for inputs, targets in train_loader:\n", + " inputs, targets = inputs.to(device), targets.to(device)\n", + " batch_size = inputs.size(0)\n", + " h = complicated_model.init_hidden(batch_size).to(device)\n", + " optimizer.zero_grad()\n", + "\n", + " for t in range(inputs.shape[1]):\n", + " output, h = complicated_model(inputs[:, t, :], h)\n", + " hidden_states_for_plot_cm.append(h.detach().cpu().numpy())\n", + "\n", + " loss = criterion(output, targets[:, -1, :])\n", + " loss.backward()\n", + " torch.nn.utils.clip_grad_norm_(complicated_model.parameters(), max_norm=1)\n", + " optimizer.step()\n", + " \n", + " running_loss += loss.item()\n", + "\n", + " avg_loss = running_loss / len(train_loader)\n", + " epoch_losses.append(avg_loss)\n", + " print(f'Epoch {epoch + 1}, Loss: {avg_loss}')\n", + "\n", + "print('Finished Training')\n", + "\n", + "# Plotting\n", + "plt.figure(figsize=(10, 6))\n", + "plt.plot(range(1, num_epochs + 1), epoch_losses, label='Training Loss')\n", + "plt.xlabel('Epoch')\n", + "plt.ylabel('Loss')\n", + "plt.title('Training Loss Over Epochs')\n", + "plt.legend()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "52cd598c-a42e-4219-aa9b-5b7e54710749", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import torch\n", + "\n", + "def plot_psth(data, title, bin_size=10):\n", + " \"\"\"\n", + " Plot Peri-Stimulus Time Histogram (PSTH) for given data.\n", + " :param data: a tensor containing the neural data\n", + " :param title: a string for the plot title\n", + " :param bin_size: size of time bins for averaging\n", + " \"\"\"\n", + " # Averaging neural activity across trials for each time bin\n", + " mean_data = data.mean(dim=0) # Mean across trials\n", + " n_bins = mean_data.shape[0] // bin_size\n", + "\n", + " # Prepare the data for plotting\n", + " binned_data = mean_data.unfold(0, bin_size, bin_size).mean(dim=2)\n", + "\n", + " # Plot\n", + " plt.figure(figsize=(10, 6))\n", + " for i in range(data.shape[2]): # Iterate over each channel/neuron\n", + " plt.plot(binned_data[:, i], label=f'Channel {i+1}')\n", + " plt.xlabel('Time (bins)')\n", + " plt.ylabel('Average Neural Activity')\n", + " plt.title(title)\n", + " plt.legend()\n", + " plt.show()\n", + "\n", + "# Example Usage\n", + "plot_psth(normalized_muscle_tensor, \"PSTH for Arm Movement\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fa5362de-9acf-4380-af3b-68acded8eb1f", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Convert list of numpy arrays to a single numpy array\n", + "hidden_states = np.array(hidden_states_for_plot)\n", + "\n", + "# Calculate the mean across all batches for each time step\n", + "# Assuming hidden_states.shape is [num_samples, num_time_steps, hidden_size]\n", + "mean_activations = np.mean(hidden_states, axis=0)\n", + "\n", + "# Plot the PSTHs for the first few neurons\n", + "neurons_to_plot = 5 # Adjust this number as needed\n", + "time_steps = mean_activations.shape[0]\n", + "plt.figure(figsize=(12, 8))\n", + "\n", + "for i in range(min(neurons_to_plot, hidden_states.shape[2])):\n", + " plt.plot(range(time_steps), mean_activations[:, i], label=f'Neuron {i+1}')\n", + "\n", + "plt.xlabel('Time Steps')\n", + "plt.ylabel('Average Activation')\n", + "plt.title('PSTHs of Hidden Units in SimpleRNN')\n", + "plt.legend()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "825b011e-0fa3-4e5f-a423-0074f069f30c", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Convert list of numpy arrays to a single numpy array\n", + "hidden_states_cm = np.array(hidden_states_for_plot_cm)\n", + "\n", + "# Calculate the mean across all batches for each time step\n", + "# Assuming hidden_states.shape is [num_samples, num_time_steps, hidden_size]\n", + "mean_activations_cm = np.mean(hidden_states_cm, axis=0)\n", + "\n", + "# Plot the PSTHs for the first few neurons\n", + "neurons_to_plot = 5 # Adjust this number as needed\n", + "time_steps_cm = mean_activations_cm.shape[0]\n", + "plt.figure(figsize=(12, 8))\n", + "\n", + "for i in range(min(neurons_to_plot, hidden_states_cm.shape[2])):\n", + " plt.plot(range(time_steps), mean_activations_cm[:, i], label=f'Neuron {i+1}')\n", + "\n", + "plt.xlabel('Time Steps')\n", + "plt.ylabel('Average Activation')\n", + "plt.title('PSTHs of Hidden Units in ComplicatedRNN')\n", + "plt.legend()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bf6d4256-8aa3-423e-9e9a-24d3cb675808", + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import numpy as np\n", + "\n", + "def perturb_inputs(model, inputs, perturbation_strength):\n", + " # Perturb the inputs by adding random noise scaled by the perturbation strength\n", + " noise = torch.randn_like(inputs) * perturbation_strength\n", + " perturbed_inputs = inputs + noise\n", + " return perturbed_inputs\n", + "\n", + "def test_perturbed_inputs(model, perturbation_strengths, test_loader, criterion, device):\n", + " model.eval() # Set the model to evaluation mode\n", + " perturbation_errors = []\n", + "\n", + " for strength in perturbation_strengths:\n", + " batch_errors = [] # Store errors for each batch in the test_loader\n", + " \n", + " for inputs, targets in test_loader:\n", + " inputs = inputs.to(device)\n", + " targets = targets.to(device)\n", + " batch_size = inputs.size(0)\n", + " h = model.init_hidden(batch_size).to(device) # Initialize hidden state\n", + " \n", + " perturbed_inputs = perturb_inputs(model, inputs, strength) # Perturb inputs here\n", + "\n", + " for t in range(inputs.shape[1]): # Iterate over time steps\n", + " model_output = model(perturbed_inputs[:, t, :], h)\n", + " if len(model_output) == 4: # If the model returns 4 outputs, unpack all (simple model)\n", + " output, h, _, _ = model_output\n", + " else: # If the model returns 2 outputs, unpack accordingly (complicated model)\n", + " output, h = model_output\n", + " \n", + " # Compute loss for the entire sequence (last output)\n", + " loss = criterion(output, targets[:, -1, :]).item()\n", + " batch_errors.append(loss) # Append the loss of this batch\n", + " \n", + " mean_error = np.mean(batch_errors) # Calculate mean error for this perturbation strength\n", + " perturbation_errors.append(mean_error)\n", + " print(f'Perturbation strength: {strength}, Mean Error: {mean_error}')\n", + " \n", + " return perturbation_errors\n", + "\n", + "perturbation_strengths = [0.0001, 0.001, 0.01, 0.1, 1]\n", + "simple_model_errors = test_perturbed_inputs(model, perturbation_strengths, train_loader, criterion, device)\n", + "complex_model_errors = test_perturbed_inputs(complicated_model, perturbation_strengths, train_loader, criterion, device)\n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Convert errors to percentages \n", + "simple_model_errors_percent = [error * 100 for error in simple_model_errors]\n", + "complex_model_errors_percent = [error * 100 for error in complex_model_errors]\n", + "\n", + "# Adjust the width of the bars here\n", + "bar_width = 0.1 # Smaller values make narrower bars\n", + "\n", + "import numpy as np # Import numpy for array manipulation\n", + "\n", + "# Define your perturbation strengths\n", + "perturbation_strengths = [0.0001, 0.001, 0.01, 0.1, 1]\n", + "bar_width = 0.2 # Adjust the bar width as needed\n", + "\n", + "# Create an array of indices for the x-axis ticks\n", + "x_indices = np.arange(len(perturbation_strengths))\n", + "\n", + "# Plotting\n", + "plt.figure(figsize=(12, 6))\n", + "\n", + "# Subplot for the simple model\n", + "plt.subplot(1, 2, 1)\n", + "plt.bar(x_indices, simple_model_errors_percent, width=bar_width, color='blue', label='Simple RNN')\n", + "plt.xlabel('Perturbation Strength')\n", + "plt.ylabel('Mean Error (%)')\n", + "plt.title('Simple Model Robustness')\n", + "plt.legend()\n", + "\n", + "# Subplot for the complex model\n", + "plt.subplot(1, 2, 2)\n", + "plt.bar(x_indices, complex_model_errors_percent, width=bar_width, color='red', label='Complicated RNN')\n", + "plt.xlabel('Perturbation Strength')\n", + "plt.ylabel('Mean Error (%)')\n", + "plt.title('Complex Model Robustness')\n", + "plt.legend()\n", + "\n", + "# Set custom tick positions and labels on the x-axis\n", + "plt.xticks(x_indices, perturbation_strengths)\n", + "\n", + "# Display the plots\n", + "plt.tight_layout()\n", + "plt.show()\n", "\n" ] }, { "cell_type": "code", - "execution_count": 7, - "id": "21bd3f12-563c-4228-8e31-3a64a86cc3b5", + "execution_count": null, + "id": "41ae5f60-f9a1-4ead-adcd-42493d32ffdf", "metadata": {}, "outputs": [], "source": [ - "#Discussion point: what kinds of inductive biases are embedded inside a model such as this one?" + "import numpy as np\n", + "import torch\n", + "import matplotlib.pyplot as plt\n", + "from torch import nn, optim\n", + "import torch.backends.mps\n", + "from torch.utils.data import DataLoader\n", + "\n", + "# Assuming train_loader is defined elsewhere and is a DataLoader instance\n", + "# Assuming the models are instances of SimpleRNN or similar\n", + "\n", + "def perturb_recurrent_weights(model, perturbation_strength):\n", + " # Perturb the recurrent weight matrix J by adding Gaussian noise\n", + " with torch.no_grad():\n", + " noise = torch.randn_like(model.J) * perturbation_strength\n", + " perturbed_weights = model.J + noise\n", + " return perturbed_weights\n", + "\n", + "def test_perturbed_structure(model, perturbation_strengths, test_loader, criterion, device):\n", + " model.eval() # Set the model to evaluation mode\n", + " perturbation_errors = []\n", + " original_weights = model.J.data.clone() # Save the original weights\n", + "\n", + " for strength in perturbation_strengths:\n", + " batch_errors = [] # Store errors for each batch in the test_loader\n", + " # Perturb the recurrent weights of the model\n", + " perturbed_weights = perturb_recurrent_weights(model, strength)\n", + " model.J.data = perturbed_weights.data\n", + "\n", + " for inputs, targets in test_loader:\n", + " inputs = inputs.to(device)\n", + " targets = targets.to(device)\n", + " batch_size = inputs.size(0)\n", + " h = model.init_hidden(batch_size).to(device) # Initialize hidden state\n", + " \n", + " for t in range(inputs.shape[1]): # Iterate over time steps\n", + " model_output = model(inputs[:, t, :], h)\n", + " if len(model_output) == 4: # If the model returns 4 outputs, unpack all (simple model)\n", + " output, h, _, _ = model_output\n", + " else: # If the model returns 2 outputs, unpack accordingly (complicated model)\n", + " output, h = model_output\n", + " \n", + " # Compute loss for the entire sequence (last output)\n", + " loss = criterion(output, targets[:, -1, :]).item()\n", + " batch_errors.append(loss) # Append the loss of this batch\n", + " \n", + " # Restore the original weights before the next iteration\n", + " model.J.data = original_weights.data\n", + " \n", + " mean_error = np.mean(batch_errors) # Calculate mean error for this perturbation strength\n", + " perturbation_errors.append(mean_error)\n", + " print(f'Perturbation strength: {strength}, Mean Error: {mean_error}')\n", + " \n", + " return perturbation_errors\n", + "\n", + "# Define your perturbation strengths\n", + "perturbation_strengths = [0.0001, 0.001, 0.01, 0.1, 1]\n", + "\n", + "# Get errors for simple and complex models\n", + "simple_model_structural_errors = test_perturbed_structure(model, perturbation_strengths, train_loader, criterion, device)\n", + "complex_model_structural_errors = test_perturbed_structure(complicated_model, perturbation_strengths, train_loader, criterion, device)\n", + "\n", + "# Convert errors to percentages \n", + "simple_model_errors_percent = [error * 100 for error in simple_model_structural_errors]\n", + "complex_model_errors_percent = [error * 100 for error in complex_model_structural_errors]\n", + "\n", + "# Define your perturbation strengths\n", + "perturbation_strengths = [0.0001, 0.001, 0.01, 0.1, 1]\n", + "\n", + "# Create an array of indices for the x-axis ticks\n", + "x_indices = np.arange(len(perturbation_strengths))\n", + "\n", + "# Plotting\n", + "plt.figure(figsize=(12, 6))\n", + "\n", + "# For the simple model\n", + "plt.subplot(1, 2, 1)\n", + "plt.bar(x_indices, simple_model_errors_percent, color='blue', label='Simple RNN')\n", + "plt.xlabel('Perturbation Strength (log scale)')\n", + "plt.ylabel('Mean Error (%)')\n", + "plt.title('Simple Model Robustness')\n", + "plt.legend()\n", + "\n", + "# For the complex model\n", + "plt.subplot(1, 2, 2)\n", + "plt.bar(x_indices, complex_model_errors_percent, color='red', label='Complicated RNN')\n", + "plt.xlabel('Perturbation Strength (log scale)')\n", + "plt.ylabel('Mean Error (%)')\n", + "plt.title('Complex Model Robustness')\n", + "plt.legend()\n", + "\n", + "# Set custom tick positions and labels on the x-axis\n", + "plt.xticks(x_indices, perturbation_strengths)\n", + "\n", + "# Display the plots\n", + "plt.tight_layout()\n", + "plt.show()" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "257161c9-9155-4dfd-b089-b12ac2725dde", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/tutorials/W1D1_Generalization/W1D1_Tutorial3.ipynb b/tutorials/W1D1_Generalization/W1D1_Tutorial3.ipynb deleted file mode 100644 index 28d17cb2c..000000000 --- a/tutorials/W1D1_Generalization/W1D1_Tutorial3.ipynb +++ /dev/null @@ -1,201 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "08528e00-ad9f-46b7-899a-862a1237d4d5", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Requirement already satisfied: numpy in /home/samuele/neuroAI/lib/python3.10/site-packages (1.26.2)\n" - ] - } - ], - "source": [ - "# Install necessary libraries\n", - "#!pip install numpy " - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "674be7a1-d379-4f80-acfb-392dd5b31650", - "metadata": {}, - "outputs": [], - "source": [ - "# Imports\n", - "import numpy as np" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "2b0cb64c-b124-45ff-8796-71dbfe51df6c", - "metadata": {}, - "outputs": [], - "source": [ - "def calculate_writing_time(total_words, words_per_day, days_per_week, weeks_per_year, average_human_lifespan):\n", - " \"\"\"\n", - " Calculate the time required to write a given number of words in lifetimes.\n", - "\n", - " Parameters:\n", - " - total_words: total number of words to be written.\n", - " - words_per_day: number of words written per day.\n", - " - days_per_week: number of days dedicated to writing per week.\n", - " - weeks_per_year: number of weeks dedicated to writing per year.\n", - " - average_human_lifespan: average lifespan of a human in years.\n", - "\n", - " Returns:\n", - " - time_to_write_lifetimes: time to write the given words in lifetimes.\n", - " \"\"\"\n", - "\n", - " #################################################\n", - " ## TODO for students: fill in the missing variables ##\n", - " # Fill out function and remove\n", - " raise NotImplementedError(\"Student exercise: fill in the missing variables\")\n", - " #################################################\n", - " \n", - " words_per_year = words_per_day * days_per_week * weeks_per_year\n", - "\n", - " # Calculate the time to write in years\n", - " time_to_write_years = total_words / ... \n", - "\n", - " # Calculate the time to write in lifetimes\n", - " time_to_write_lifetimes = time_to_write_years / average_human_lifespan\n", - "\n", - " return time_to_write_lifetimes\n", - "\n", - "# Example values\n", - "total_words = 5e9\n", - "words_per_day = 1500\n", - "days_per_week = 6\n", - "weeks_per_year = 50\n", - "average_human_lifespan = 80\n", - "\n", - "# Uncomment the code below to test your function\n", - "\n", - "# Test the function\n", - "#time_to_write_lifetimes_roberta = calculate_writing_time(\n", - " #total_words, \n", - " #words_per_day, \n", - " #days_per_week, \n", - " #weeks_per_year, \n", - " #average_human_lifespan\n", - "#)\n", - "\n", - "# Print the result\n", - "#print(f\"Time to write {total_words} words in lifetimes: {time_to_write_lifetimes_roberta} lifetimes\")\n" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "48f02975-a2cb-4b4a-8fc0-479a406c74f1", - "metadata": {}, - "outputs": [], - "source": [ - "# to_remove solution\n", - "def calculate_writing_time(total_words, words_per_day, days_per_week, weeks_per_year, average_human_lifespan):\n", - " \"\"\"\n", - " Calculate the time required to write a given number of words in lifetimes.\n", - "\n", - " Parameters:\n", - " - total_words: total number of words to be written.\n", - " - words_per_day: number of words written per day.\n", - " - days_per_week: number of days dedicated to writing per week.\n", - " - weeks_per_year: number of weeks dedicated to writing per year.\n", - " - average_human_lifespan: average lifespan of a human in years.\n", - "\n", - " Returns:\n", - " - time_to_write_lifetimes: time to write the given words in lifetimes.\n", - " \"\"\"\n", - " \n", - " words_per_year = words_per_day * days_per_week * weeks_per_year\n", - "\n", - " # Calculate the time to write in years\n", - " time_to_write_years = total_words / words_per_year \n", - "\n", - " # Calculate the time to write in lifetimes\n", - " time_to_write_lifetimes = time_to_write_years / average_human_lifespan\n", - "\n", - " return time_to_write_lifetimes\n", - "\n", - "# Example values\n", - "total_words = 5e9\n", - "words_per_day = 1500\n", - "days_per_week = 6\n", - "weeks_per_year = 50\n", - "average_human_lifespan = 80\n", - "\n", - "# Uncomment the code below to test your function\n", - "\n", - "# Test the function\n", - "#time_to_write_lifetimes_roberta = calculate_writing_time(\n", - " #total_words, \n", - " #words_per_day, \n", - " #days_per_week, \n", - " #weeks_per_year, \n", - " #average_human_lifespan\n", - "#)\n", - "\n", - "# Print the result\n", - "#print(f\"Time to write {total_words} words in lifetimes: {time_to_write_lifetimes_roberta} lifetimes\")\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "f9065f36-3e2d-435e-802a-1736754759d9", - "metadata": {}, - "outputs": [], - "source": [ - "#Exploring Llama 2\n", - "total_tokens_llama2 = 2e12\n", - "total_words_llama2 = 2e12 / 1.5 #assuming 1.5 words per token" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "bb48ab5f-090b-46ee-84b4-5421e7720027", - "metadata": {}, - "outputs": [], - "source": [ - "# Time to generate text\n", - "time_to_write_lifetimes_llama = calculate_writing_time(total_words_llama2, words_per_day, days_per_week, weeks_per_year, average_human_lifespan)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "8aadbb9a-5dd6-4438-b7ad-64926750451e", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "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.10.12" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorials/W1D1_Generalization/W1D1_Tutorial4.ipynb b/tutorials/W1D1_Generalization/W1D1_Tutorial4.ipynb deleted file mode 100644 index 163a7071b..000000000 --- a/tutorials/W1D1_Generalization/W1D1_Tutorial4.ipynb +++ /dev/null @@ -1,349 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "b65e10e2-51fd-465b-bafd-1f1087df8487", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Defaulting to user installation because normal site-packages is not writeable\n", - "Requirement already satisfied: torch in /home/samuele/.local/lib/python3.10/site-packages (1.13.0)\n", - "Requirement already satisfied: torchvision in /home/samuele/.local/lib/python3.10/site-packages (0.14.0)\n", - "Requirement already satisfied: trdg in /home/samuele/.local/lib/python3.10/site-packages (1.8.0)\n", - "Requirement already satisfied: typing-extensions in /home/samuele/.local/lib/python3.10/site-packages (from torch) (4.9.0)\n", - "Requirement already satisfied: nvidia-cuda-runtime-cu11==11.7.99 in /home/samuele/.local/lib/python3.10/site-packages (from torch) (11.7.99)\n", - "Requirement already satisfied: nvidia-cudnn-cu11==8.5.0.96 in /home/samuele/.local/lib/python3.10/site-packages (from torch) (8.5.0.96)\n", - "Requirement already satisfied: nvidia-cublas-cu11==11.10.3.66 in /home/samuele/.local/lib/python3.10/site-packages (from torch) (11.10.3.66)\n", - "Requirement already satisfied: nvidia-cuda-nvrtc-cu11==11.7.99 in /home/samuele/.local/lib/python3.10/site-packages (from torch) (11.7.99)\n", - "Requirement already satisfied: setuptools in /usr/lib/python3/dist-packages (from nvidia-cublas-cu11==11.10.3.66->torch) (59.6.0)\n", - "Requirement already satisfied: wheel in /usr/lib/python3/dist-packages (from nvidia-cublas-cu11==11.10.3.66->torch) (0.37.1)\n", - "Requirement already satisfied: numpy in /home/samuele/.local/lib/python3.10/site-packages (from torchvision) (1.23.4)\n", - "Requirement already satisfied: requests in /home/samuele/.local/lib/python3.10/site-packages (from torchvision) (2.31.0)\n", - "Requirement already satisfied: pillow!=8.3.*,>=5.3.0 in /home/samuele/.local/lib/python3.10/site-packages (from torchvision) (9.5.0)\n", - "Requirement already satisfied: opencv-python>=4.2.0.32 in /home/samuele/.local/lib/python3.10/site-packages (from trdg) (4.9.0.80)\n", - "Requirement already satisfied: tqdm>=4.23.0 in /home/samuele/.local/lib/python3.10/site-packages (from trdg) (4.66.1)\n", - "Requirement already satisfied: wikipedia>=1.4.0 in /home/samuele/.local/lib/python3.10/site-packages (from trdg) (1.4.0)\n", - "Requirement already satisfied: diffimg==0.2.3 in /home/samuele/.local/lib/python3.10/site-packages (from trdg) (0.2.3)\n", - "Requirement already satisfied: arabic-reshaper==2.1.3 in /home/samuele/.local/lib/python3.10/site-packages (from trdg) (2.1.3)\n", - "Requirement already satisfied: python-bidi==0.4.2 in /home/samuele/.local/lib/python3.10/site-packages (from trdg) (0.4.2)\n", - "Requirement already satisfied: future in /usr/lib/python3/dist-packages (from arabic-reshaper==2.1.3->trdg) (0.18.2)\n", - "Requirement already satisfied: six in /usr/lib/python3/dist-packages (from python-bidi==0.4.2->trdg) (1.16.0)\n", - "Requirement already satisfied: charset-normalizer<4,>=2 in /home/samuele/.local/lib/python3.10/site-packages (from requests->torchvision) (3.3.2)\n", - "Requirement already satisfied: idna<4,>=2.5 in /usr/lib/python3/dist-packages (from requests->torchvision) (3.3)\n", - "Requirement already satisfied: urllib3<3,>=1.21.1 in /home/samuele/.local/lib/python3.10/site-packages (from requests->torchvision) (1.26.14)\n", - "Requirement already satisfied: certifi>=2017.4.17 in /usr/lib/python3/dist-packages (from requests->torchvision) (2020.6.20)\n", - "Requirement already satisfied: beautifulsoup4 in /usr/lib/python3/dist-packages (from wikipedia>=1.4.0->trdg) (4.10.0)\n", - "\u001b[33mDEPRECATION: omegaconf 2.0.6 has a non-standard dependency specifier PyYAML>=5.1.*. pip 24.0 will enforce this behaviour change. A possible replacement is to upgrade to a newer version of omegaconf or contact the author to suggest that they release a version with a conforming dependency specifiers. Discussion can be found at https://github.com/pypa/pip/issues/12063\u001b[0m\u001b[33m\n", - "\u001b[0mDefaulting to user installation because normal site-packages is not writeable\n", - "Requirement already satisfied: Pillow==9.5.0 in /home/samuele/.local/lib/python3.10/site-packages (9.5.0)\n", - "\u001b[33mDEPRECATION: omegaconf 2.0.6 has a non-standard dependency specifier PyYAML>=5.1.*. pip 24.0 will enforce this behaviour change. A possible replacement is to upgrade to a newer version of omegaconf or contact the author to suggest that they release a version with a conforming dependency specifiers. Discussion can be found at https://github.com/pypa/pip/issues/12063\u001b[0m\u001b[33m\n", - "\u001b[0m" - ] - } - ], - "source": [ - "#Install and imports\n", - "!pip install torch torchvision trdg\n", - "!pip install Pillow==9.5.0\n", - "import torch\n", - "from torchvision import transforms\n", - "from PIL import Image\n", - "import matplotlib.pyplot as plt\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "ccd05d66-ae6a-493c-b682-f1f897585bda", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Path to the image\n", - "image_path = '../static/img_1235.jpg'\n", - "\n", - "# Open the image\n", - "image = Image.open(image_path)\n", - "if image.mode != 'RGB':\n", - " image = image.convert('RGB')\n", - "\n", - "# Display the image\n", - "plt.imshow(image)\n", - "plt.axis('off') # Turn off the axis\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "0134350e-0bb3-479a-a81e-6cb92f5fc120", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", - "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAARCCAYAAABvrb82AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOx9d3hVVfb2e0t6hySUkNAJXaQpIAhiwQJW0EGxt2HUcSzj2MaOjmId21hRAQsWxC5YUUGK0nsVQijp/Sb33vP9wbMO713ZF6OTGZ3ft9/nyZPk3H32XnuttVfb+5zrcRzHgYWFhYWFRTPC+1sTYGFhYWHxfw/WuVhYWFhYNDusc7GwsLCwaHZY52JhYWFh0eywzsXCwsLCotlhnYuFhYWFRbPDOhcLCwsLi2aHdS4WFhYWFs0O61wsLCwsLJod1rlY/H+N22+/HR6P51fdO23aNHg8Hmzbtq15iSJs27YNHo8H06ZN+4+NYWHxn4B1Lhb/s1i9ejXOOecc5OTkIC4uDm3btsXZZ5+N1atX/9akWVj8fw+PfbeYxf8i3n77bfzhD39AixYtcNFFF6Fjx47Ytm0bnn/+eRQXF+O1117Dqaee+rP9BINBBINBxMfH/2IaQqEQGhoaEBcX96uzn5/Dtm3b0LFjR7z44os4//zz/yNjWFj8J+D/rQmwsPil2Lx5MyZNmoROnTrh66+/RlZWlvvZn//8ZwwfPhyTJk3CihUr0KlTJ2Mf1dXVSEpKgt/vh9//65aBz+eDz+f7VfdaWPxfhy2LWfzP4YEHHkBNTQ2eeeaZCMcCAJmZmfjXv/6F6upq3H///QAO7KusWbMGEydOREZGBo444oiIzxi1tbW46qqrkJmZiZSUFIwbNw4FBQXweDy4/fbb3XamPZcOHTrgpJNOwjfffIPBgwcjPj4enTp1wssvvxwxRklJCa677jr06dMHycnJSE1NxfHHH4/ly5c3I6csLH472MzF4n8O7733Hjp06IDhw4cbPx8xYgQ6dOiADz74IOL6+PHj0bVrV0yZMgUHqwaff/75eOONNzBp0iQcfvjh+Oqrr3DiiSc2mb5NmzbhjDPOwEUXXYTzzjsPL7zwAs4//3wMGDAAvXr1AgBs2bIFs2fPxvjx49GxY0fs2bMH//rXv3DkkUdizZo1aNu2bZPHs7D4PcI6F4v/KZSXl2PXrl04+eSTD9qub9++mDNnDiorK91rhxxyCGbOnHnQ+3744Qe88cYbuPrqq/Hwww8DACZPnowLLrigyVnF+vXr8fXXX7vOb8KECcjNzcWLL76IqVOnAgD69OmDDRs2wOs9UDyYNGkSunfvjueffx633nprk8aysPi9wpbFLP6nIM4iJSXloO3k84qKCvfa5Zdf/rP9f/zxxwD2OxTGlVde2WQae/bsGZFVZWVlIT8/H1u2bHGvxcXFuY4lFAqhuLgYycnJyM/Pxw8//NDksSwsfq+wzsXifwriNDgjMcHkhDp27Piz/W/fvh1er7dR2y5dujSZxry8vEbXMjIyUFpa6v4fDofx8MMPo2vXroiLi0NmZiaysrKwYsUKlJeXN3ksC4vfK6xzsfifQlpaGtq0aYMVK1YctN2KFSuQk5OD1NRU91pCQsJ/mjwAiHqCjPd5pkyZgmuuuQYjRozA9OnT8cknn2Du3Lno1asXwuHwf4VOC4v/JOyei8X/HE466SQ8++yz+Oabb9xTX4z58+dj27ZtuOyyy35x3+3bt0c4HMbWrVvRtWtX9/qmTZv+LZo13nzzTYwaNQrPP/98xPWysjJkZmY261gWFr8FbOZi8T+H66+/HgkJCbjssstQXFwc8VlJSQkuv/xyJCYm4vrrr//FfR933HEAgCeffDLi+j//+c9fT7ABPp+v0Ym1WbNmoaCgoFnHsbD4rWAzF4v/OXTt2hUvvfQSzj77bPTp06fRE/pFRUV49dVX0blz51/c94ABA3D66afjkUceQXFxsXsUecOGDQDQbE/in3TSSbjzzjtxwQUXYOjQoVi5ciVmzJgR9aFPC4v/NVjnYvE/ifHjx6N79+649957XYfSsmVLjBo1CjfddBN69+79q/t++eWX0bp1a7z66qt45513cPTRR+P1119Hfn7+r3pNjAk33XQTqqurMXPmTLz++uvo378/PvjgA/ztb39rlv4tLH5r2HeLWVg0AcuWLcOhhx6K6dOn4+yzz/6tybGw+N3D7rlYWCjU1tY2uvbII4/A6/VixIgRvwFFFhb/e7BlMQsLhfvvvx9Lly7FqFGj4Pf78dFHH+Gjjz7CpZdeitzc3N+aPAuL/wnYspiFhcLcuXNxxx13YM2aNaiqqkJeXh4mTZqEm2+++Ve/QdnC4v83WOdiYWFhYdHssHsuFhYWFhbNDutcLCwsLCyaHda5WFhYWFg0O+zu5K9AtG0q/fR2OBx2rwWDQQCA3++Hx+Np1MfPPfltGlP6D4VCjfoJh8NoaGiA3++H1+uNuM7tHMeB1+uF4zhwHMeljcfzeDwIh8Pw+/3u/XKfoKGhAeFwGOFwGF6v1+1T2ng8HvcnGAy6L3f0er2NXtTINDU0NMDj8bhz0HyQ8eQ++RF6hfaGhga3D7/f7841FArB5/O5tDmOA5/Ph1AoFEGzzCEUCrn3hsNhhEKhCBoEJnl7vV6EQiH3UIDQGQ6HI3jOY9bX10fMJRgMum1jYmIi+OL1eiO+etlxHASDQZc+uU/aAftf9y/yYh4KHTJXoaehocG9l3VI6438HwqFXJpFX4V3LEvWS2nPvJDX5Yium2jjfqSNyJZ1S+TI9PD9MpZJ31jOwgeRtfBe7uF1xzJi+bP+yFrQ61l0RObCOi79MD2sxyJ31jGROeu6tOE5MC+EBuGX/gZYE6xz+Q+ClZbflMsLpzn6535EQWVxyOeiGGx4hQ79WyBKL/3wwtaLW5RVL2Q23kwjLxo2emKAReGFJr24eDxtCLRTELqlfzZuTLPJoOj5MK/Y6PE9Yry1oRVjwGPzj54T0yAGkf8WJy2Oh+mUeWrnLmNrw6odg/BM2skYbFy1Hpv4yfNmWvi7bJinPG92kkK3dvqsi/pH7mXa9dx1kMRt9NxYLjxX7aDYkXMbno9uawoQeR7cTjtDDm5YxmwLuH/pC9gfLDB43sxXtiE6kIoG61z+C9BGRv7+d/pjBZT+wuFwRGSroxZpx9lCtMyHF4y01UZaDD5Hixyha2OuHZG04Xtlscj/2jixMdfGhsEG3WSwmW6T4WB6pH/hbTRHJu2FJr2oBRwparnKPdpISnQs7TjzAICYmBhXVtooyP3aAem5RwsyuC+RF2flPKaeB/OCDa3JCYg+6OCF+2SaTWtAtxXoQEkHJpovuo3pmja28r92itrB68CB7+dxNF+lvcmxmZwb6zevd7YPLEcd6Oi+ObttCqxz+TegI7KDtdNKrf/+JWPqaEsvDtMC1pGaNoIA3DRaK6Iu+7ADEnC5SLIVjuCENi5PaR6wE+MFyfPW7YLBoOt0THLQRlA7M47iovGX58iLjfmpjS/znftzHCfCSTEP9d98v/CUHS7zUTJRHXGbnCvL2xTwcD8mZ8UyNRk7lqvJOHNZRsbgHw5ATFku96UdDH/GwYoel9sHg8GITF4HNxomfpmcnbTRa5GdCa8Z0S9dpmY+c7+sqyJL1nfOCrVsdVs9P1Mp1VTCPhisc/k3oA2QFqRc07VLU4msKThYVKWVj+kwpbOmcXUUrvvh+XCtXy9CbeQ4q5KFzHsuco+OfJkOMRJcmuPSk+aDplkbZV3u0/sOeu6y+NnYcd1ajJfcI3sdMk925lyuMMmO++U5a+Pu8XjcPTXpR2ekOhM0yYfHFVpZdjL/aM6Y/zY5HQ7COJPjLFuPHy2rjbYXpmUm92onxuMJXZwVMp81z3RGpdeAzmi0k+K1YJKJKYNh6FKuXi+CaPpimo/so5oyGC7BsfNrakBsnct/ACYjKQJnJxMt+zD1xe20UWfF0M5BOze9MGVhxcTERCiUaT/END+T43EcB/X19fB6vYiNjY2IIIEDyi8bmzqS0hvqskfk8XgQCATcTVHNCzb4zAvOqmS+3Ld8xlG6NhCScTGPtJHSho/3FeS3jpyFZl7IbNzZ0EaL3EV2Imc5BMHy08ZPHBfro5azCdp5scPRBpP/ZoPJjk8+Z96xzmlZ6gzBtNa085exdVAn8/d6vW4GbIr+WZYSNIieinE2HZzRczaV5vQ8TKUxlrXWWbnHcZyIvTctd60zejzmM9OgAxRp0xRY5/Ir0FRHwMoBwFVCdizaych9OkLUkY1OW+V/vYDYuUWLTE0OiaM5UTjTaRVZnKbMScpWfL/P50N9fb27GJg3wh+mn52m9GUyKqaojvkqp7TYWOvIV1/Xm6BCg6lvHTnzb6FT856dnuarnicbDZlrTExMo9fRsEPVAYeMrw1QNCck89aRcbTImY0nj6H5wWMxNC+kFCifaWfD6ytaUKAdDJcwhR5xLjoI4ExWl+vYMZvWr3Z2up9ozl/PR/OIgy/tPNhRaCeleW8ai3XDdP8vKYkB1rn8R6GFCjQuI5jSTK2EOuqUNtqo8ThawXhsLqPoEyxa+dhYsIPg46WabhkjHI48Aiz96o15MdrRygXctyx6U9Qnc+RoXDsak7GUMTl6l8/Z4bCz0byV+5i3Jhq1MRLZSyah2+n5M8+YF9oRRTNuJl0SWZnKYVpfTAZGR7XsHKIZOW6v6dfZpNbJg0Xveq9GO2cJLoTnPHa0IEHuYyepS6gsH32vdswm2ZramOTH2S/TxHIwOSWTLeB+uDSmN/N18NNUWOfSjNCORModWpEE2qAAZgMn0KdveExZcKw0bBi1UWMjo6NLNjLS1mRUtPPjmrrJiMmc5V7HcRodhZTjtexc2agwL9gxMs+Eh+Joos1Z6BAaZCwuFTLfBXrDVRtnpon/B9Do2SM2eto48I8YRelHnnFhx2iKZlnv9HhsVE0ZKc+BSy7a6DPN8hyMOGPtMHkM5o0poxI6+RoHPKZ2rI8MDg6kDZdID+bgdMbPFQLWQ6aTHT9nkY7jRF33Juh5acdocjyahzwf3qfUGbIpgOFyudahn0OTnUs0j97U+6J58l/Sn8lr/jv3/pL7m9ovG1zgQFSoHQKXw3Rkpo0S02jqm6+LAsk1Mfg8BisoEKlkuvQg/XPdX8aOZhT4ft5fkfZS346NjXXH14ov/ZmcrE7/TQZBPhcDcrCFJeBTblIm4f0QcUQ6UNBrw0SPzmRMeicOQhs0bq+DC5YTByame5mvcj/rBu/dsBFhwyKy1PLRRp4DGa3rpoyGHb8u93I7njO31zzmNnyvx3OgrGTa52GHIvrDjkKvRVOApteBDj64vMy84PtNGYPMleXB1/Ra1PyNNo78rY9Qm/Q3mu6a8Itf//LvGmMTtJf9ubZ8T1Pvk3tMzx00B6I5PjbQB1voHBVqR6Szg4ONz225T73YeWyml9vwwpYFrMsBpojbZEzlR4y28IWzAr0g9ANjzENTtMm/+ZkcoPH+Cc9T98UGWo+hI3ZTKY9LL5oPpocueTGzUdEQ/ms5sPEwGWTpW3gdzUgyvfqpegkKpB9tyJh+5rfm08HKWbovXYpi2fJT/FrPTOOx3JkG6Y+zQm1cNT3amTNvtGPQxj7aAQo2/DqAZFlqecu9kk2x7DWP9XWmS8DBgQ4Iot0TDf/xsphOX5vLOf3afnQ62VwwRQwCjvLlFBVvLrOx0BGq3kCUNiaF4evymXamjrM/Qm1oaHBPFQk/9BgsM1E2U3TEY5o2UOV+ppmdDLfjhStjyH36SXQdiZmyL92XLkvJwjFFdzow4MMJ2oAID00GnKNer9eLhoaGRvV9LrUwHfK38EqiXjnOrQ0OyyVa8KUDFaFb5sWykramY9/MYylnsp4Iv0w2QBtyXf/X61M7Cp5DtHlzG02H8JT/5/IWjyXt9D4ht5NsSI+lqwtap3V/mi9Mn14/wqfY2FjXnsi48rfIVeTCvJc++RmZaA5d2kcLbk1osnP5pca4Kd5NG7Bf0/cvpYsF0BwOhgVg6lMWpghRCy/aouVFoSM7NnymKFdHGaxc3AdHR3rBC33R5qUNF9ev5Tffw2Pz3oy0q6+vR3x8vNteeKWfTNdj8yLn//VzRWxItaPUhlnLlBeX5olJh7gvXTaSsTmziiZHNiihUAgxMTGNok5tdDhy5eiYaZa27My0IeGNceYr9y3X9TMpcl0+Y15pXjNN4sBlXNPpRB1Zm2THchJaRcflf12aM9kiznrltKHWI+0QdXCoZcJlTZ198lsU+HNNYzgcdoPDqqoqpKenIzk5udFBEb2OdWAm8wqHI09pSgDGevBr8B95K7I2UqbP5G+9gH8O4XAYpaWlxpLJwdDQ0IBVq1Zhw4YNB3UsTaVJt9PzMpVPgMYlKlZIbbh0ZGMyLJoGbRh5DNNYnPL/3GYglyJMPODSgIxhmqfJ0Os6u7TXzx9IxqPHZl7ww3lsnOvr6yMeeBR+8dPZHMHr0orms/RjamPij8xbb+ZruZqMqTbMACJO2Ol7ODPieegfloPczzSxU4gmd4aJbh2xc1tpY6JZHroVmZvKUHxNZyMaLDNx7jobEnDAxZF9NN0W6IoCz4d5xoZdxtG6rfdKmY/BYBBFRUVYsmQJampq3FIh06NlzTxjB6vtAM9FZ/7BYLDRIZxo+Lecy88pmW6jGc/tWJlk09TU/+7du/H++++juro66iLWggyHw/jqq69w2mmn4eKLL8a+ffuMytfUa9GgF5FWdq2EQqeUSdhQRRO2ni87Cf1bL3BWUuYdl3I4CmOatbPkRSaGU29cmhYSX+fsTN+r6WB5aAfKC0XG0pueco8sYP2bI2J2GsxTMTBaP7TcRKZCD+9faEfDc9PzZxq0cdOOQBsuGZ91U48ZTd81L7ROs8PWBwxMjov1hmVn0gvWZ5N8eD46+ub5cHYvuiD2hflpyi54zvxWackYNM0HmyvTxTrK9DBNzEOWo7RjnVy6dCl++uknxMfHR9zL7ZhWbVdMjkycrnZEmtdNwX/8+1xYKbUT0gYuGAyirq4O8+fPx9NPP42qqqpGBq22thZffvklysrKomYfko7LPXv37sUjjzyCs846Czk5OdiyZUuT6TcxMlpUJO31IgEi6+5aWNpQyximBa0jGa7fa97yotN9sWEXYydt5LQU0y9z0LTpvQMen+cVzUDo4EGuy080I8zj8EIXOk3OVb+dWe7hyF3Trh21DmS0Q9f3aIPPjkjPSzt6HRSIXPShCDYePCcTvcIHLhWKHIVXco31mHlvMsQAGhl5bZBMRsq0DrhfTT/fawqKeGwdVGiHCxx4Tb4O0uRvU8VA64Q4HTbo0TJsrXuadpYFBzqsVwBQXl6OmTNnwu/3IzY2ttFaZ53hdVZfX99oz094w86Os3/54dJ6U/CrnUs0gyIwlWJ0G72Ag8EgVq9ejWuvvRY333wztmzZ0ujeUCiEffv2GRUlYmJUZlm4cCFKS0tx3nnnITU1Fbt37z5oSc1UWvo5mIy7CORgJRBT5KcXNTsK+eENPSkfMU+5BCD9ym8dAWvll9qv1NKlbMQGjSMp7o95J3Txvol2bHqRCh36xZc6WuYFx0ZEZxymqJb5w7RoefJT28xDHo8XLvNClz51AKANmclo6THlJxAIuEZCZKCdDs9Dr0Xmq0lvteHmNjozMdHOuqGNPzsUU/SvZWBaU/yjT2kBjV95b6oe8GfR5MA6xrIwOUquurCh1uvCtPZM8zXptfQTDAZRUlKCQCCAvLw8l976+voIp6GdMeuCttWaT0KrOCLuT7+LLRr+rdNiPPloYKaaGCz/h0IhFBcXY8qUKSgrK0N8fDwCgYA7htxfWVmJ7du3uwv4YDQIY3/88UeccsopaNeuHZKSktyMSN+n01rg5994zGDDIsonp0g037Rw5X7JHFhB+B6JPOvr6wEcODMvjsC0byKbkbyI2KByuScYDCImJgb19fXYuXMn8vLyEBcXF+FU9PMi2jDI/+wg5JQUZyN8Hyt4tFKfdiosL+1MBaaz+3xyRsvclInpF0jqtxqYNsx19mQ6qcP6wIGC/K0NuHweFxcXceyUM1jRD6HBtMlrOg1mKoGZDJDJIcl8TLpqysaFJil/69N9nLlpWcucZa48P5Gtzj6iOXTpQ8bhQyB6zkw/2zKWpbZpvJfH9zOYP1p3o62VhoYGbNiwAfX19cjJyXH7lvf48Vi8nrTN5GoFy0Xu12tNdFi/ciga/iNlMVPGwgZUfrOwysvL8fjjjyMmJgaXXnop4uPjkZCQEBFhBoNBlJeXIy0tDQkJCREM14ZHxqyursbKlSvRrVs3+Hw+JCQkoLq6+medIs/j56AVhhcGRzk6ipG/eWFxJMYRlFYa/jwQCODLL7/E/fffj/Ly8kY0h8NhFBQUoKyszBi18jjiqHbv3o0bb7wRBQUFjYwlRzhMq54vR9H61Je+T/8tfbBRiaY78psjRcm4pL1Eb2K0xdExj1hObGCiRayah6yrOjjguZsMtO5D6ODMz9SeZcfQzkzu4WxMZM3XdKbN/evSGY/PfNSO36RrzF/+zTIwyV3zUsqN9fX1jYJXbZA1z03GWzs1+V/3qR0zy1764/0iU3aknR8HfMx3XbIKhUIoKipCMBhERkZGxB4O6zpXFkR+kt3ooJDXj+YBgIg+ta5Fw7/lXEyG17R4TAokiiHMmz59OhYsWIBrrrkGSUlJKC8vdz0xL7iffvoJCQkJbjStFxDT5vF4UFZWhl27dqF169aNHFxT5xbNIJjmraNp+YzLAKzUrFjymcxVR2H6JX6iNNu3b8c999yDRx55BOvWrXPnKI4kEAhg2rRpKCgocDMcvfg40mloaEBRURH8fj+SkpIaLSp9KszkCNmpaEci97Dz0A4rmhz0b7lPR12m6JMzLl1m1M6Mx5G/tfNg/TbJVDtLvR54nhy963Ui8zM5Y+aBjuQ5C2K9MpWJeB78N/NABznaQEl/OhrXhlXLltcH98HjRNtXBICamho888wz+OijjyKCGjaq/GOih2mOlnHJ/+xoZD3pbFYct/4xzVtKaZoOnjeP2dDQgMLCQsTGxiIlJcX4bBrrd1VVFdavX4+tW7dG9Kv5weBsxvRdMU1Bs5wWawo4m2HB1NfX4/XXX8e7776Le+65Bz169EBdXR2qq6sxbdo0VFRURBjTBQsWGKMF3pgDDqSYpaWliI2NjfjO52ilLpPi6v9NhidaXyZBRMtidCSnDZI28IJAIIC5c+ciIyMDXbp0idisk0inuroaixYtavT9GbxodFnknXfeQV1dHWJjY93vcdcbsXoOQOR3dPAmZ7SoP5pym0oE+kf3o418MBh0aRcey+dsrA9mAFluom/iMLWs2eloQ6nlGg7vr5GXlZVFBBMyV+axPimkDafJ4Mt9wkuWsw5g+JqpP15jWg+j8YqdtclhST+yT6GdovzmTW3TmnIcB4WFhfjggw+wfPly9z7JVAKBAAoLC1FeXg4g8rX7nJGYyqT8w7rF2Q7zQ5ea9XMyeg0x73j/zBR4yjNO8tLYgoICdO/e3S2RMj3cfyAQQEFBAe666y4sW7YM4XDYfeiSnZHp4IwOPA4mcxOaPXNh/FxEGA6HsWbNGqxZswZ///vfceihh6KmpgYbN26E3+9H7969kZiY6C6U2tpaFBQUIC4uzn0vlWaAKIIYt23btrk0BINB1NTURNQmmwJtVHksHcVweYEVVi9qXigmJebFz5EDG5RQKITa2lp88MEHOPbYY10+s/ELhUKoqqpCfX19RHlFL1SeRyAQwLJly9CuXTvExcW5jl3q/NrJcRTExlCMUTAYxL59+7Bu3TpUVFS4Y+zZs6fR2XyhhdNwfrBO+MF0cHTHfenojJ2M6Y248hmDecX6qzds5TobUwYbHZnfmjVr8PXXXxufy9HOiMfShokdjn4Qj9egjCEGXRs5vVajOS1xjHzcmufGY7Gu6P0sDqy4PKczXZ1p6zWwatUq7N69GzExMRHzbWhoQHl5OR577DG88sor7ljRqh0sb+1AdXvWG8k+TPt1rC86uBJ6hBfMU70u5HkvWc/Lly9H27ZtXX7Jd8tIe+FZMBjE0qVLEQqF0Lt3b5dHLFtTEMRyN2XSTcGv2tDXTkIbKo6CeKJa6erq6lBRUYGzzjoLPXr0AABUVVVhyZIlSElJwWGHHRZxUqmyshJVVVXIz89HXFxco3FZEdatW4eEhASkpqa6iyEQCGD16tU4/PDDf/F8tcIBka9P4LnznE1KKe1MkUE08MLlaKusrAw+nw/5+fkIBAJITU2N6IsNbyAQiIjeTXPy+XzYt28fKioqkJOTY/zOFc0XlrVEjeI8NmzYgE8++QTV1dVIS0tDx44dcdlll2HJkiX49ttv8ec//9ldFNIHvzYkEAgYX4uiMyftoDXvmX/s+DX/5T59MEI7ZNZlj8fTiE+s7+zIuN8lS5agqKgIRx99dETmyKVLPq2nsxstB/mcDXlsbGxEOdDr9bqHQYTnHGVzf/I3G2PJBjdv3owFCxZg9+7dGDJkCAYNGoTExMRG0b/uj2nniJ+dOztigbThAIn7iYmJQefOnSN0VMpH3333HaZMmRKxbkzr0ORI9FxENqbqhzgOzvLkHq2X2qYIHeIUHceJeEEo91NVVYW6ujqkp6e7b6EWPRH+CS11dXVYuHAh/H4/0tPTDxoI6DciCN+ZRh18HQy/6q3IAlM2wsSxkpg2i3766SdkZGSgW7dubvnlxx9/xPbt2zFhwgTk5ua6/fl8PlRUVKCiogJ9+/Zt9J4pRnl5Oa644gqcd955aNeunTt2VVUVKioq0KVLl5815iYFAyLTRy4/6AhAC8Rk+DTPBNIfK5fmtRiQtWvXIhAIICYmBvn5+WjXrl1EO6/Xi/j4ePh8PtTV1TU6mcOQjGDBggXYuXMnhg4d2qgU4vf7IzbHg8EgSktLUVNTg0AggE2bNmHZsmVYsmQJNm3ahGHDhqFPnz447rjj0KpVKwQCAYRCIcyePRtpaWnu3pnMkaNTnWkx37WuyVw5MtQOWeQn19mosK6KgeCxOYpjmbOT0s8UaF3SBtTj8biZnDhUkY98oZr0qzNkoZVLwUJXXV0dPvroI2zbtg2XXXYZMjIyIuTO/WkaWa+17oVCIVRXV2POnDl45ZVXMHbsWAwdOhQAsHfvXrRt29b9KgCZp9ZdU9bARp91QO9jMD08n5KSEoRCIbf0xTJbsmQJhg8fjkMOOSRibuwEGSb5aR5pByi80aUwnoveU+UxtCxEPqwTXq/XDQ4DgQA8Hg9atmzplslkXUp/QmNZWRnWrVuHYcOGua9X0o6V6WHd53lr+9cU/OLMRTsTE6FcCmJvLhMXo7R48WL07t3bZYzjOFi9ejUCgQD69OnjMk4iss2bN2P79u3o3Llzo/7EKITD+0+ebdu2DYmJiaiqqoLf70dCQgJ27NiBtLQ0tG7dOoJ2oZ8NiCgGL16OCoBIBdKLiA33wYSlFx33xVkFR63AgSfNd+zYgZqaGixZsgRJSUlu2iuRnshBOzmt0Dx+QUEBMjIy0LVrV1fhOAvlewOBAO68805s2rQJcXFxCIfD6NOnDy6//HIAwJYtW5CVlYXMzEzXyZWWlqKgoABjxoxx+ShzDoX2v/Z++fLlePLJJ3HRRRehf//+rix4bL3vxotEy4IzFu1UeWw2XNqoA3DLFhUVFdiwYQNKSkqwY8cOOI6DLl26oG/fvmjVqlWE4deOSeD1et0DGOJI+cg464o2YsKz+Ph41xnJHH/66Sc8/PDDuOOOO9w+RIbCM60fUsYUfvEelqzBQCCA999/Hy+//DJuv/129O/f3w2AuL02nDpT0UZVB6Q8P1MAK9fFkf74449oaGjAJ598gpNOOgkJCQnwer2ora3FokWL0LNnT7eMLtB7dLy+tLFlOcpc9Ea+yFPLS8/dxB/+LacYY2Nj3TW+adMm7N27F23atIHf70d5ebkrI7/fH1Gi5W+pDAaDKCsrQ1FREYYMGQK/34/du3cjKSkJKSkpcJz9mS1nS3p9CV9M30Hzc/hFzkV7dDbEzEhuJ4oif0sbv9+P0047DYmJia6iV1ZWYu3atWjVqhUOP/xwN/2rra2Fx+PBli1bEA6HkZub645jElZJSQlSUlKQm5uLffv2IRwOo6amBmvXrkXbtm2Rnp4esdij0c+06znX1dUhFAq5R6JLS0uRnp4e8fyBPoPPY8g4vPikHZeudKTF1+WUSWlpKT788ENMmDAhYmEy7Q0NDaipqXHfysxGlnlQV1eH5cuXY9SoUcjMzGx02kvzKy4uDldddRX27NmD1NRUZGZmomXLlnAcB9deey0qKyvxpz/9KWIuu3fvxpo1a9x2Qqcs2HA4jPT0dOzcudM1CvzGAP0WV94TYho1nzXtzE9pJ3oq9PAYoVAIe/fuxZtvvonly5e7ZZfq6mqMHj0aX3zxBQCgffv2OPfcc90atyloERrkWS4d8QodjuNg+/bt2LlzJ4YMGeLSYTLm8lNaWoqioiK0atUKSUlJETrV0NCAuLi4CJ7rcpte4+Hw/rLymjVrMHPmTNxwww3o169fhF4LXXwvO2gOzLRB1ZE838+yFCcojsXj8bi6dNhhh6GwsBDLli3D0KFD3U3vyspKDB8+3B1PB2i8sc008Nrh9Sx9yD385WicVUo7vTfM8xcZyrj19fUoLy/H2rVrAQCDBg3C6tWr8dBDD6GgoADZ2dmIi4uD3+93y8Vc9pZ9GT6wwnuc7733Hj7++GO0bdsWV155JbKysiICCe1cdOJgyngPhl9UFtMGmZ0FC0HAbTj6E+KSk5MjBLpnzx4sW7YMgUAAzz33HEpKSrBmzRrExMSgdevWWL16daN+HMdBZWUlCgsL0a5dO8THx6OsrAwJCQlISEhAYmIiamtrUVFRgYULF6Jr167u8zNMs+l/niun+pIdyb7PypUr8eWXX+K8885Dq1atIhSTecQLkI27KZKWa/X19e4BBOaVREzV1dXYt28fsrKycPzxx7v0Sl0dgFuK4oVhkpmUFpYvX47Ro0c3ekEdR87scHJzc12HX1dXh2AwiL1792L16tW4/PLL0bt3b3cujrP/dTzV1dXIyMiIcOLM+w4dOmDChAkoLCxEr169IsbUZQmmz6T4Ig+J5lgejuNEvG1YZwmc9TU0NODdd9/FDz/8gIsuugjdu3fHs88+iy1btuC2225zTya9++67uP3223Httddi2LBhjWiTkl/Hjh2RkpISsbhZD8Vobdq0CTfccAOuu+46nHbaae7r9oEDGazc6/P5UFlZiaysLMTHx6O2thYLFizA0qVL0aNHDxx77LGNdJJ1gasNck1kM3v2bAwdOtTNJGV8efBW5MG81LrD17VO69/ytw7AuD8xxKeffjq+/PJLzJo1C4MHD4bH43FPj7Vv3951rHLvnj17kJSUhIyMDPcZGZEzZ9CaFk2vdhoSjFVWVmLdunXYu3cvRowYgTZt2kQEDqJbANzndMrLy/Hmm2/i1VdfRV5eHjp37uweYHrkkUdcRzV79mysXr0an3/+OQYNGoTY2Fj38EJMTAyysrJc2svKyhAOh/Hkk0+iRYsWyMnJwebNm1FVVYWWLVs2KuWaHLzQy3apKWiyc9EeS3s5McA6jZV2slikLyZcFOWLL77Ajh070Lp1a+zduxdnnHEGJk+ejFatWsHv9+POO+9EeXk5cnNz3RMvu3fvxt13341Vq1Zh5syZyM7OxqxZs1BZWel67KqqKmzevBk//fQTLr744gg6ZHFKer9hwwbMmTMHRx55JAYPHhxhjFnR09LSEAqFsGjRIjz66KOYNGkSMjIyEAgE8NNPPyEpKcktv/EmKxtljvTEwInir1u3DoFAAGlpaejVqxdSU1NdpyRKHRsb60ZxI0eORIsWLSL43tDQgJKSEixbtgy1tbWuUTI5UPmprq5Gamoq8vPzI4yNwJTxiFGTSLChoQGrV6+G1+tFnz59GpXjtm7diuTkZHz22WeuPI8++mh3jsD+BTdu3DiUlpa6R1X1u8F4M1NnJ6yn/Dc7dl7o2uFqIyJtCgoKcOWVVyI/Px+1tbUoLi5Gfn6+K4/OnTvj6quvhtfrxfPPP4/DDjusUWYkp4vatGmD+Ph4N5uUz/XJwoEDB+Lhhx9GaWkpNm7c6B5+4XmIrILBILZs2YKuXbuitrYWN910EyorK90j68OHD3cdAWcGnDlJECD0BINBLFmyBBs3bsQdd9wR8dW3Mr5EzfrL0Dhr4eum/3UJTa7x/9y+uroaixcvRtu2bdGjRw9UVlbijTfeQGFhIdq0aYNVq1bhiCOOQEJCglt2rKurw5w5c/D6669jxIgRuPLKK129kvE2bNgAn8+Hjh07wnH2v89ww4YNiI+PR/fu3d0DFqKXfBwY2H8o6ZlnnsHKlStRV1eH6dOn45ZbbkH79u2xcOFCHHLIIcjJyUFdXZ3ryEKhEBYvXoz33nsPtbW16NevH1q2bIlRo0YhPj4eXq8XOTk5SE5OxpgxY/DFF1+gRYsWWLRoEVq2bIkZM2agoqICCQkJ6NChAy666CIkJCS4j3J07NgR55xzDmbMmIF+/fohMzMzgucmJy/rgL/u+z/mXEzRovzPC9VxDpyQkRq1GAGtbBLNS3nH5/PhiSeewJFHHon4+Hh3MmVlZdi5cyd69+6NhIQE1NfXY+/evZgyZQo+//xz3HrrrWjVqhW++OILfPnll6ipqUFtbS1atmyJ6upqfPLJJ4iNjUV+fr7LQP0upmAwiNmzZ+Ouu+7Crbfe6kZAMn+JOGURVVVVYdq0acjOzsbIkSMBAN9//z2mTp2KVq1a4R//+AfS0tIihFVUVISKigokJibipZdeQmFhIS655BL07NkTPp8Pq1evxq233upmaxs2bMBZZ52FCy+8EEDjkzWpqalo27Ytjj766EYptji+lStXusZfDLKOUMSg+f1+ZGZmRjx0qmXKUbPcw0Y7FArhhx9+gOM4bhQlillXV4evvvoKxcXFeOONNzBmzBhMnz4dGzZswLXXXus6TMdxEBcX5747iTf4RWZ8OkZkyqUPzjqYZnbupr0pdlSim9LuxBNPRHFxsVvS2r17Nw4//PCI8ooY2xYtWjQqg8kDqsXFxfj++++xdu1avP322+jXrx/y8vKQmJjoBkQejwepqalITEzE8OHD4TiOe91x9j/DUFNTg4SEhIgvq1q4cCH27duHf/7zn+jSpQtOPfVU3H///Rg6dKi7RyN8DIfDjeTHgQAA1NbWYvbs2ejWrRvS0tKwb98+1NbWuk+IJyUluXZAVwJMmUe0jJ3bR4uSRZZSPVi9ejU6dOiA5ORk9OnTB0888QQWL16MYcOG4YcffnDXsDzKsHDhQsybNw+lpaURXxon/dbW1uKzzz7D4sWLMXXqVHg8Hjz//PMoKipCbGwsWrdujfPPPx+1tbWYP38+Vq1ahUsuuQTt2rVzaSwoKMBnn32Gf/zjH2jRogXuuece/OMf/0B+fj6+++47HHnkkbjxxhtRU1ODnTt3Yt26dVi5cqV7etDj8SAzM9OlKSYmBsuXL0eXLl3g9/sRHx+PlJQUjBo1Co7j4P7770eXLl1wwQUXICMjAwsWLMCmTZvQp08fxMXFoUuXLrjiiivc/bgxY8a4+sxfQaH3nMTO6OPLTUWTnQsfwWMjptNgNj4A3A0nIZw36HkhV1dXY8GCBTjkkEPcY43Sv3wuJ5hKS0sxf/58vPjii9iwYQMee+wxHHvssVi4cCGee+45XHbZZbjjjjuwc+dODBo0CAkJCZgzZw5uu+02JCYmukoqz8G89dZbGDp0KIYMGYLTTz8dr732Gnr06BHhWDiqFAf5zTffYPXq1Xj66acRGxuLNWvW4JlnnsHpp5+Op59+Grt373a/xCcY3P/9C1dddRW2bduGE044AZ06dUJlZSWeeeYZTJkyBYmJiSgqKkJcXByefPJJxMbG4tlnn8Xu3btdfsrGmxhb+foAyRh8Pp87r7vvvht5eXm499578dBDD2Hbtm2NohU2Jo7jICMjA61bt0Z5eTnat2/vZnfaeejavGQvHo/H3bfp27dvRM2/vr4eBQUF2Lp1K4YNG4Z7770XWVlZ6NOnD55//nlUVFRg3759WLx4MY4//ngkJye79wqt77//PubNm4eEhAT88Y9/RJcuXdzMk/f2hD8xMTFYtGgRduzYgXHjxrl66vXuf9fZnj17sGDBAgwfPhytW7du5CRY/l6vFz169MDy5ctRU1ODhoYG1NXVITU11eW74zhYvHgxvvvuO1xxxRX45JNP0KtXL7Rt2xbh8P6vfnj66aeRlZWFmJgYhEIhLFu2DFVVVRgxYgRat26Np556Cj/99BPq6upwwgknYOzYsW5mnZSU5B5uefvtt9G7d2+0bt0aPXv2hNfrRXl5OcrLy7F161ZccsklOPzww/HYY4/BcRxccsklblDFwZ2sV31MtaGhAfPnz8fKlSuxfPly5OXl4corr0RNTQ06duyI+Ph49OvXD0ceeSSKi4sRCATQoUMHN6vnNcMOi50bl4aYJlN5Rj6TUtzWrVuxe/duXHDBBfD7/cjOzkbfvn2xYMEC9OjRAy1atEDHjh1d/d2wYQMeffRReL1eHH744TjjjDMQCoXcQz9xcXGuY7/ooosQHx+PH3/8EUVFRbjuuuuQnJyMZcuWYfHixZg3bx6SkpKQlJSEp59+GrfddpsbwBUWFuLoo49G9+7dERMTgz/84Q+4/fbbkZOTg2HDhmH9+vVYu3YtPv/8cyxduhSdOnVy9/P8fj9atWqFb775BqNHj8bevXvx0Ucf4fLLL3f3d+Pj41FcXIyKigpUV1cjJiYGEydORHZ2Nurq6tCmTRssW7YMXq8XRxxxBAYOHIhWrVphw4YN2LlzJ9LT0xETE4NAIBCxpsW+SxVF9F+CK87umoJfvOfCCsNKI210mYVLKPoEiExINkZ3796N/v37Izk5uVHJprKyEsFgEAsXLsTixYuxc+dObNmyBU899RSOO+44rFmzBg888AAmTpyI/v3748UXX8TKlSsxcuRI9O7dGz/++CNOPPHEiIVTU1ODO+64A0uWLMF7772HRx99FFu3bkX37t3dTUA9BzE2RUVFeOWVV3D11Veja9eu2LVrF5544gkcccQR6NmzJ+rq6jBz5kyEQiH87W9/Q1xcHFauXIldu3ahpqYGFRUVOProo5GYmIhPPvkEwIEHpZKTk12nvHPnTrdExQsuFAqhrKwMS5YsQWlpKdauXevubQSDQXz99dcIBAK45ZZbkJSUhJdeegm7d+92ec7lBb6WkpKCK664AjExMRHfoCl8EMfk8XgiNquZR2VlZVi9ejUmTpzoZgRi7FevXo2Ghgace+65yMrKcg10OBx2ebhs2TJkZGRgzJgxbsnAcRy8//77ePHFF3Huuedi0aJFePbZZzFlypSIzIp1Un46duyIVatW4e2338YJJ5zgRvp79uzB7bffjqKiIsybNw/XXHMNevbs2Uj35Zi84+w/XdOhQwfU19ejrq4Ou3fvdmVVWlqKBQsW4P3338eYMWPwxhtvYPfu3aitrcWUKVOQn5+P7du34/rrr0enTp0QDAZxyy23YPLkyWjXrh08Hg/ee+897Ny5E7fddhs8Hg82bNiAurq6iAVfU1ODRx99FMOHD8eQIUMijuxu374de/bswZgxYzB48GA3O7722muRnZ0dYRhEhswzLn34fD7Ex8dj/vz58Pv9OProo5Gbm4uWLVsiKysLfr8fe/bswaxZs/DDDz/A4/EgMTERxx13HEaOHBnhLNiO6CxG9igKCwuRm5uL2NjYiPIv673QWF9fjzlz5sDn86Fnz55ucCNr/8UXX4THs/+4rryE9eWXX0YgEMAf/vAHjB07Funp6aiqqsKHH36Idu3aYciQIdi0aRPq6urQq1cvOI6DVatWoV27du5hnd69e+OBBx7A+vXrceedd+Ljjz92s1t5tmvBggU44YQTkJiYiHB4/2Gf7OxsTJw4EZs3b8bnn3+Oe+65B9nZ2fjjH/+Inj17YtmyZZg/fz7S09Nx22234fHHH8eUKVNQUlKCiy++GB07dnT1LBze/5R9XFycuyl/1113ITExEZmZmcjPz0dOTg4yMzORmprqZtCpqalo06YNFi1aBJ/Ph9jYWBQVFSEUCqFFixbIy8uLqLRwIC1j/pIM5hd9zTEbfG1wdTtTpCJgLyjM2rRpE4qKijB06FDXaDEKCwvh8XgwaNAgjBo1CsuXL8ezzz6LkSNH4ttvv8Utt9yCSy+9FKeffjqqq6sxePBgfPjhhzj22GOxcePGiGhflLu0tBTFxcW477778MILL+CRRx7B3r17cf311yM9PT0q/X6/H2vXrsXSpUtxxx13YMeOHXjzzTfRtWtXjB07FgsXLsSOHTvw2muvISUlBaeeeioOOeQQxMXFoaSkBG3btsX48eNRWFiIjz76CMOGDYPXu//htm+++QZ9+vRBTEwM9u3bh9WrV+PEE09EbW0t9u3bh/Xr1yM7OxsdOnTAG2+8gW7duiEQCOCHH37AuHHjXAO7b98++Hw+ZGRkuCe6YmJiUFVVhdraWmRmZjaKEEWZevToYTwKKo5ZP9Qn1yWjWbt2LdLT0936tJSDPB4P3n//faSmpmLAgAGuLL777jsAwOuvv44+ffogNzcXRUVFblkVADZt2oR58+bhpptuwpAhQ5CRkYFbb70VtbW1EcevRSfF2ezcuRPvvvsuTjnlFPdlf8B+ozZ37ly0bNkSjzzyCKZNm4bHHnsM//rXvyJkLuUmjtjS09NRV1cHv9/vZleVlZX47rvvUFhYiPPOOw8PP/wwLrvsMhQXF+P+++/HunXr0L17dxx77LFu5FhbWxux1+H3+7F48WIMHDgQbdq0QX19PQ4//HBUVlaiuLgYLVq0gM/nw+zZs9GjRw+cfvrpES8SdBwHmzdvRjAYxMSJE/HRRx9h+fLluOWWW9ClS5cIGYoxZuOhs9RgMIj+/fsjLy8Pbdq0wamnnuoaOPmK3ZkzZ6JNmza45557kJycjPXr1+O+++7D3Llz4fV6MWrUKBx55JHuepfN68LCQiQmJiI7OxvV1dWYOXMmPvroI0ycOBHjx493dY+PwHM5uLi4GLt27UL37t3dgyGO4+Dwww/H22+/jS+++AL9+vXD9u3b8cEHH2DLli346aefcO211+KYY45x3yxeV1eHH374Ad26dcOOHTvwz3/+ExMnTnQP0ZSVlbm2RyoE4fD+E6kff/wxvvnmG1x55ZXw+/2YPXs2PvzwQ9TU1OCqq65yS3efffYZ+vfvjx49eqB3797wer1o3bo1unbtivT0dHi9XvTr1w8XXXQR8vPz0a9fP1xzzTV49dVXceKJJ+LII490s1yRYdeuXdGuXTu0a9cOd999N3788UdkZ2e7zp+/s0d42a5dO1x77bWYPn06PvzwQ4waNQoJCQk49NBDkZOTE/E142IvObv8j+25SFTNdW4uhwn03gwbMB01sYP59ttvEQwGMWjQoIg2goqKCvcIXWpqKnbs2IHq6mpMmTIFS5YswR//+EecddZZ8Hq9SEhIwKhRozB79myccsop6NatGwDgwQcfxMMPP+x+c1tcXBwA4IMPPkBWVhY++ugj3HjjjRFRF8+P5yHR0/Tp0zFv3jxMnDgRZ5xxBnw+HxYvXoyMjAw8+uijmDt3Lj766CPk5+cjLS0NlZWV8Hg8+Pjjj/HJJ5/gxBNPxEknnQQA2LhxI5YvX46bb74ZALB9+3Z3M/KOO+5AcXExzjjjDOTl5WHlypXYunUrrrvuOnz88cd46KGHcOGFF6Jt27bYu3eve6BBSkM9evTAd999hzvuuAPnnHMO2rRpE1FX5X0H3qQVoy3OhjNOLWvJCL/99lt06dIF2dnZrjH3+XzYtm0bli9fjuuuu849Drtv3z4sXLgQoVAImZmZuO666/DSSy9h06ZN7jHdsrIyTJkyBccddxwGDRrkjpOamurOT+bKUbzs/axduxaTJk2KeEK5srISCxcuxEUXXYSYmBjk5ubi448/dksAvE+jyzgS/Ph8PvfEY2xsrLvvtnz5clRXV+PDDz9EcXExbr31Vnz22WfYsmULxo8fD693/wNx4qDkeGltbS2qqqrQqlWriIcoX3nlFVRVVeEvf/kLvF4vFi1ahMmTJ7sGkuUyYMAA3Hbbbdi1axdef/113HzzzRHPK7ED1if0eH3Kei8tLUVhYaGbIQlNVVVVePHFF1FRUYGrrrrKXVMJCQlITk7GypUrcfbZZ+PVV1+Fx+PBiBEjUFFRgeXLl2Pp0qUoKChAXV0dLrroIixYsACVlZUYM2YM1q5di/LycqxYscI9EOLz+VBTU4O6ujrExcUhJSUFGzduxK5duzB8+HAkJye7c2jTpg369++Pn376CSNGjEBKSgo6d+6Mbt264ZVXXnH7k1dJrVixAomJiXjqqadQXV2NIUOGYOjQoa6da9u2LZKSkty5x8fHY+LEidi1a5e7OS+HVlJSUlBYWIgrrrjCpUm+d+X44493jffpp5/uOlopdyYkJODss89211PPnj3x97//3R1TbKXX60Vqaip69erlZka5ublo166d6/g5+GOb5fV6MWzYMAwYMACVlZXw+/2IiYlxs1feC+PypKxzthFNwS/KXGRgAae4phqprtNxxMT3V1dX47vvvkPHjh1do6f7z8vLwwUXXOB6+lGjRuHCCy9EKBTCo48+6p7sEkN47LHH4umnn0ZxcTGOOuoorFu3DjfddBMeeughjBo1Cp07d0ZcXBzS0tLw5ptvIj09HTfeeCMuv/xy94gxl/yEHmH8IYccgsmTJ+Pbb7/F1VdfjTFjxrj11qKiItx8880YNmwY4uLicO2112Lfvn0oKChAixYtUFxcjBUrVuD666/HYYcdhp07d2Lv3r3YuHEjJk+e7DpDeaPA888/j3HjxmH06NFIT08HAKSlpeHqq69GTk4OjjrqKMyfPx9//etf0aJFCxxyyCHIzc3Fu+++i/vvvx+xsbFYtWoVunTpgrPPPhv9+vVzlYUzTH1iScta5CFt2cGwnMvKytzSXiAQcKPA2tpaHHbYYTjiiCPcDflNmza5J6Ckdp6ZmYk5c+Zg27ZtyMnJwYIFC5CVlYWTTz4ZANyvUejdu7e7r9WiRYuIjXPH2X+oQV59wTolhx2CwaC7Z7Njxw7k5+dj+fLlrmPOyclBbm6uu5/DGbnots/nc496C99Ehzt06IA//elPaN26Nfr164fPPvsMDz30EA4//HD069cP4XAYXbp0QWZmpsufyspKJCUlueNVV1dj+fLlOP/88xEXF+fqBAd5juO4fG7Xrh3S0tJwyy234KSTTsKAAQMiaJf9ipqaGndzmE958VqWrLKqqgpHHHFExP7cjh07MG/ePEyaNAlJSUluILJgwQKsX78eN954I4YMGYJVq1Zh0aJFGDFiBFavXo37778fI0eOxF//+lc8++yzuP3229G9e3f8+c9/xty5c1FbW4uXX34ZS5cuRWJioktvYmIiOnXqhBNOOAHp6eno2rUrhg4diqOOOsrVPZHBqaee6h697t69O/Lz87F06VL4fD6sXLkSO3bswKeffoqkpCSMGTMGw4cPx+zZs5Geno7Ro0e7e4c+nw8nn3yyG+SIbnXv3h133XUX6urqkJiY6O4Pjxw5Em3btkWHDh1c/cjLy8Pdd9/tHvtlQ63L09qG8oOfHAhkZGRg3LhxSEhIiLDPEvDo7ELvHcbExLiVGV7bbO8kgOayJjucpuAXZS6Smh2shhotQpJJ8skMmUxycjKuueYadOjQwX1VBU/a4/GgX79+GDBggDtWTk4Obr75ZpdZTIPsW5x00kmuN2/dujXuvvtuzJ49G++++y4uv/xytGnTBrfeeit69eqFPn36uO15bBYOe/H09HRcddVV7ruxJArJzc3F3Xff7W7kH3bYYbjjjjuwdOlStG3bFlOmTHFPUEmZqqioCCkpKTjllFOQnp7uRo3Dhg1D9+7dkZ6e7l6X+ck+TDgcRrt27XDvvfdi/vz5iI2NdQ2BHEvNyMjA9ddfjz59+iA1NRVA5KtI2MGIfNhI8w/zWb8ChRWcHbRE1z169MCdd96JjIwMl6/i4K+55hr06NEDjuNg+PDh+PHHH7Fy5UrMmjULixYtcp1kUVER5syZg1dffRXBYBDLly9368Xt2rXD2LFjkZeX5y6MQCDgRu7Cu5KSEkyfPh1HH300YmNj8f333+Ott95CXV0dALhlq65duyIuLg6tW7duVH8GgMTERLRs2RJVVVUu77xeL1q1aoXp06e7L/30er3IzMzEqaeeinHjxqGmpgY+nw/FxcU44YQT3IBITi/pyoA4AZFZSkoKfvjhB3ffo6GhARUVFUhOTkZycrJ7HP7kk0929xbD4TC2bNmCjz/+GHV1dcjJycHw4cPRsWPHiFe26wymqKgIWVlZrjGSz2NjYxEbGxtx+kzWTkpKCrp06YKVK1di48aNOOOMM1zHIw+cyr6Nx+PBxIkT0apVKzQ0NGDp0qXYsWMH/vrXvyInJ8f9FtmuXbuiR48ebvSfl5eH22+/vVGg6jj7n7t64oknIr4uom/fvpgwYQIeeughtGvXDqNHj8bxxx+PFi1awHH2H3aQdce8j4+Pd3nPp+mEdv3eNjlYwespKyurUVmP7YnoiFxjW8o2SNr4fD60adMmgk5eq7wW5R5px8fHueQrbYWeaA6K7fnP4RedFhOipZYnhMr/wIGHuvTGKke3XM+XMtapp57qlt1YwWXS0j8bQ/bI3L9O8SRKPvroozFq1Ch4vV73waPu3bvjlltuiejD5JllPH4q1u/3R7y6Rj5PSEhw+RUXF4djjjkGo0ePjhC2OIqUlBQMGzbMpZG/9Cg2NhZt2rRp9GyKpgkAUlNTccopp0Qo9SWXXIJwOOwaOVkIrIgM5u2aNWvctxmYlJjr/HJKSuaUm5uL4uLiCBmITiQnJ0dERAMGDMCcOXMintZPT0/HDTfcgNmzZ+PVV1/FxRdfjLZt22Lfvn244YYbsHHjRkycOBHHH3+8m9rv2LEDixYtwpo1a9C6dWtXJ9u3b4/s7GyX1qqqKrz22muoqanBUUcdhcceewzffPMNzj33XJxwwgnu5qeOAsWpMN/i4uKQnp6OH374ASeddFJEVKcPO8ixz3A47Dp4kQvLQZ57YT3MzMzEV199hR49esDv92PChAl4+eWXMXfuXGRmZiI2NhZdunTByJEjkZCQgKSkJIwePRoPPPAAXn31VezatcvdS8vLy8MZZ5yBnJyciLeD83qTn9raWmzcuNE9AstHt1NTU+H3+1FWVubunYVCIQwZMgTvvPMOzj//fNeoH3bYYQiFQtizZw8GDhyITp06oaGhASeffDKGDx+Orl27wuv1YtCgQVi3bh3OPPNMd8xjjjnGpUdkyvsfTDsjOTnZPb0lduXMM8/E6NGjERsb6x4a4vVgKuFz1UUHmxyE6YA7mv3QGQIH47y2WRYCXnPsLATaoTC9zCMei4Mm5gfrn+Zvs2cuElUBcGvbOoViAySGhicn94iCsicW42eaCNf7eBPZlFnI/yJwoYWZzkaWI1GZC0ci+hXmfJ8YVi4vyX1cNpK/+RUm3FbXNIXfuhTDjoOVU5e02HjLA1DSlqMq5pls3oXDYbz33nt48803ceuttyIhIcF9s65WOL6XFfa0007D+vXr0dDQgNjY2IhjqazUwH4jLAZd+COOtkuXLrj66qtx0kknuWOnp6fj8ssvxxlnnBFRNmjTpg2GDh0aISPHcXDqqae6mVMwGERlZSVKS0vdDOqwww7DCSec4J44Yv5xwCHz1UFLy5YtsXHjxkaRLeu98FWMnNDHT7UD+51N586d0bp1a3ceXq8Xl1xyCXbs2OHOVZ6JKSgocJ+nkfKdGNNJkyahV69eKCkpQWpqKjIyMtCrV6+ITVvWJa1XQm9cXBx27drlloBkLomJiRgyZIh7Ak30NTc3F3fddRe2bNkCv9+PnJwctxpxwQUXIBgMum8qz8jIQIsWLVy+9ezZE3fccYebxelqhPxoA6oNp/CUnaHYLznIIp/LvbxeeW3xmMwbtkPaNgjYWHMbnZHwOjzYdb6m+9TOge/TQb62QexcomVAuq+mwOM0sWVFRUXEhDibYGayd5VojZ0CT0L+lwUn/bKT4ghCe2Ael+8zeWKOHDl7EsXjMTgj4/GZ6XxEVuYr7eS31MWBA46KszrhHzsVjobkut5I0yUaKYGJgxaH2NDQEPGWWs5AhGaZl9S2Fy1ahLvuugtXXHEFTjrpJIRCIddB8CLjjWSeS11dXcTDlvIaGrlXl35k/jw3accZon5Fhy496IBDYDKaMg7X1llnhDccGMj/kqUJLUVFRSgpKUGXLl0i3tnF4/NC5gArWpQoMpTTjUIrl1ZELrx2OGAQueu1xzLj4IX1inW5pqYGlZWVSE9Pb/TV4iITrjawPjBdbBA5qGM7ABw4SKDXk8yL+afXi2k8Xjc6IGXd4Ht1ZK/H4mxI2yvtEDVt3I/un/VTv+lArun1InKUcfR9bMPYVrGeCj26JMi066xoyJAh+Dn84lfuMyOZABGiHDmV5yQARBgGNvDAAeZy9MvGXxaWPKSmPbqmUQtYrrNScBTKNVsdtfF1ftaDGc4lH15Q/BXNOkNiPmjnJOMLWHG4H13G4Lq5/G961Yt2VnJGH9j/dbHvvPMOOnfujOOOO869n40c08g0swMXuYrh4fba8euoEEAEb1hP2BixokczDNJGy1tHczob1rSxvrJRkui7ZcuWruMxlSRM0S3LWI8pDgxARIDCa0Jkp40jj20y7Jwdar4LnyVw8ng87p6DXpPCAzb2PE9+UFPrtcnZM606kNGBo8xDl7GYp6InXD3Q65rbyvy4T+G5tBGwUzEFM9qps+xZ5tJeX+c1quUi/GC6WNe4iiK6Y3KiJnA/PJ5uo+1rNDTZuZhSQ16MMrB8rjMYneXI/cwAMYqsFNwHM4AZwYZfRwumdI+vCS0CNl48J62MQlO0bIAh97PC8OaeaYPMlKGxorDBE5pY0eS1O3oBaj7xBp8oU4cOHdw9Ax3x6sUg90oZlA0nvzGW56r5q0scJuMDNP6+lGhy1m2Ybu2gNB81HRy1sszkHn4vlUY0vdH0RzNAfJ8OJuQefrkoO13ND51l8/iadm1sTRG/yUGxrohxYoeix+B1AUS+vYP702OyjFiXNU+1PrFN0fw2PYCrbYa2T6zLbAuZX7zmTTot1zng0+25P16zJp03jWNypDqj5jlrGekDWc3uXFipw+HIZwp4YImYRSCS3otyy5dDCfQmlTb8uhaqGceGSkcMHAEKtJHR85K/mZE6KuI5M91yrzae/JnQoAXEhlfG47ozLxpWLCAyhdbGxHEOvGBP+uPIhHkVExODCy+8EJs3b46I1FnptZEKhUIRD73qhcGLV2jR7bh/bUR05Mj98t6f8EsvJJNRYv3hdrqN/G1yCLo9648pStQGi+ekDaSeJ7dnHeLf+iixZGlCK8tNO1itwzyujvpNAaXJ0JnmyTzVvP05XmtDq3+zsdTZh8mxCUwBKbfjcXQpinmpecrjaLvFtoADBx24MXQAxvaC91WlT6HPlJEzfXod/Fyg9B91LqxEulwAIGKx68UmToYnIm3lXibcVDLRzNfM0pGGqb30bVpMQKTCcb/yt8yBy0Zyn27P48q9rKimBcn3svB5gZvG4LE5WjMplsiDI0U5fivPfrDTMmUsUvrQBlzzgPswPU/BSmsKJEzzZL3RGSSPx/MwRXc6a+A56LlHyyY5oNH7GJpWk76Lo9SGm3mjgymTA9RGVdaglp023h5P5GEKuVcbf47eTZ+xQ9My42BOz88k72jBHMtaBwPaFpnWs+7bVHIz6THziuUh/NDBBu9DmeykloW2Xdom6OqBdqYm2lhmMjaPwxkYy0uvJ56XLtcdDL/qKDIznVNNPmXDSsTpOjsX/ZJAFpgYGk5vtcJxdGvyygKTx2Ul086DmagXou5P021aGOyA2DmZFjzTYHphnNAm/WpDpUtsbAw4mmFjxX8LOOPUm4La2Wgl132JjJgW3ZcpauJMTvrUhoOf/dE8jmastB5wG9E5TbcJ7Ox58XPwwTSa9EzzgmmSMUz0ch86qtXzMq0F09zZ+Us7Doa0XjPNnCmbjKLJdpjmoo0cy4KduA5q2BbpdaX/1rqgnaqJHh1ssiw5QDPJzhTU6LVgcjrRZK8DBv6SMJM91fdre8Kf6/ma9Kep+EV7LjIxFrg20iYHIMrJTJY+2Bjqk1Qm5TzYYtMLlRVcaGHwwpT/ZTHxyYxoyqcNOSuSlGzYIDKNulQhPGGlEnpY0DrSkOv6gICJXyanb4JO9X8uctdBhmm+egOSnbdO4eVvHT3z81Qm46llJZ9r58dz4UybnYOWN4/JvNXGXNNmWrzcNxt6TbuOMpmPrN96TXF/et68trQzYv1j3sm42slE0zU9fz6RaeIP2w3NG5PTYHlp+fD4fF1XTFgnTHSwnnHgoisOTDPrhPBKrvPepg6YmY/a3mkHrOetr/GYMi+dRbEesJ1jmXD/Mj/JrrUdjYZf9H0uHEULTJvRJuVhLy33cZ8yEblPp7KmCWnDY1Is6dcUBWlatSHmKEA7LJ63yYhzpM4KxfTI3yZ+MY2scLpvNt76XVi65KMdrsl4cX+imKy82hjK37z4eF9I5iHXdK2aecSLg/fptANg3rDhNH3LJI/N9Gq6+f9ouqbnzZ+ZDC0bZJYBGzXTOCYZyWdaBtHuNdEnNHF2ZopgRT+ZXuGpSfbch+Yxy0ogesEGHogMLk3GNZoMWD9ZDjxP09piPrMT1rpiWi86yNWBczQHwPRyNUjLWGeQTKfJqUYr48u60IEk96N5yXLV6+2X4Bftueio7+fa89/RolptAKJ5RpNicVuTgdYLADCf1GBlZnr52s+VB/ScecFoRRY6uG+BpoFpNJ2q0QuUFUZH9OyAOUoTZWbjL3Phko7mGfOWfwutJrpYmXmPQp/PNxk3HjvaYmE5awOgZcTy4c+00Yg2jikwkHu0/mi56MhZy95kQKQN81mumYyn5h2f3pI+dbbDjpFp0ZkH982BhOaR6ILoq3a0TJeWDc/DNGdNi0l+WlZ6DL5XOwDTAQaWpYl3TLdpTJ4z67/WFb3uHOfAYRitG9ECPvmMsyYOvpj3mie6X11FaAqa7FyAxuUSvqYjIp64NtamUg2/iE9HnVoBdCYg/ch4minMPJNQGCbvz/dwOYcNNCsS/8h1HSl6vQdOs7GyMu3sdGQe/KYE6S+aodWGT2djptICEFnD1c5Q923KEEw8EZgcCkf53E765ZKf5qlJt1i2slBNumlaJKYFKvSY7tdRJf8v9LGhZr4y7TyenufBDKLJ+ZmcjeaJHl+Xb/Va5XXO/ZiMf7T1xoZV84n75TWijTrPQ8/L9JmJL0wbj8nzNo3B8uH1rMdge6gdPvOf6dDZtWkPh8eSKgXLh8fntSD96GCCr7O+MD0mfjYluQB+xSv39Usi9SIXJugFI9f1QpTJmtJhWZgm46ydFAuRnYo2gkw396sXNu8x8aIQA28y2NoAM5+kzKMjVa/X2+iBMKZXNvW1YZK+ORvhPQemgXmqU27ms7TT+2PM32hRkimIEP4xffrVO0ybnls0I6YDE5a58E5HwjI2H583OWDWMf5f86upMNGoeWUq1/L9zEeTsTWtMa0HJsNsclrCK702tD5omBwXy0EbPE2PbqP1TBtzLYeD8eXnaNcZCF/XlQFuwzbCVDI0nYzV92qeRaNTgizthLUt0etEy1HrBV/nvjQ/RW6mV3RFwy/ec9GlGha2LF4xovzFTOxpHcdx37As98mkpC8dCWmjqAWnaeVUPJoR4ShbOxkd1Zv60Jt8fD8LW+iRNyfr735nJdU0s/OQfnjhAmj0/Q1MT1OjD+2MdDs2uNph6wUh8jfJhqN4ydz4+RumRfrlt9VqmjXt8j+X1UxzEfnoIES3k9/sDPgeoV2ib97bM+1Hmpwej2GKWOU+0+uItBMUueiAQgceAv0mBz0m98vz1xUFnT3ImCwPmQMbQG1YmTbt7HUwwuMJL3XEzgELr+domQi/mFYfnGFwX9ph6q94+DnnFAqFIjbLdXt2utp2ie6xY9F2i22cKeBg3WYd0vrF82kKmuxc5EEdVjAmTK6z8ZQ2+jSQZD96sty/Nkz6dRLcnjeETR6YnQEvZrnfJEzNSGkj8/V6I1+0qekypZ8yX8lGtLOUe/lBQ13r5uhfR4UyrjY4vLiYRp6vyRDryMzjiXwFSLRISMbQhkDemcV6wREpy4FLhkyzlo0pYxLdEgfGxh9ARPat79c6wHMxZR3CH257sCjU5CDZSPDC1+OY+MtrTzsPkyGV/zkA0CcSTeMBB9Yvy1D4y0+46zFFDhJE8itt2FnpMaOtQ8c5EJCa1jrzSH/OPJfrJh3UZVpeA1rurBvclw5EeE7ixISvvI9qcjA6yA2Hw+4Xg+k23E7bI+2gdRDGv8XOyDNQ+lDWz+EX7bmw0spgsncgRo9P7PArr+U+0yT1sVRhsHhkn8/nftsgGzIdqZqU27TQ9QkhYT4bTXZW2niyg+HxtdJrB8nlNB1BSB/CD+GfzgJ0FCrz4bftsiJyf8IXbYz4M7lPy40/i9YnLwhNiyn60sbQJFd9P8uNP9dtWAdNZRY9JstT80bTqAMTrSsMkzMxGT0TH37O4XNbzU9+INlkOOQz/aYNLR9NI2D+Ijn+zfMWvWbDKRUNvT7lf/38m3boWkdMtoCdtdZDmSevQc7GtAx4TC1nkzOLxjceh4N0kRe/vV3o1RUfpknrgozJgb3WC/5bOz49JtshsTusKz+HX/wQJRPBBOrIX5+C0J5bmCg/+pQSK5M2ZswkZhqnliwMrXgyBzYenBEwHdwXR1/aKbDRZcXmI7VMv/BMPtPKz/2aNtd0f6KYJqPJc2Ge6DEPNi9tCDSPBaygOrPSZSLtbDgDlc/14pQxtHM3BQBA5LMzJkOldU73Z9qr47nqTFLzyhTtauNjkif/z/rAxkl/Hq0PU/DGbST7Z/q0TphKoB7PgX0A/UVbzAOuOvDLPbXMOFjikrKpnWT3zHvNX47K9XxkzuyMtB4wHbodz9Nkc7RsTL/lb3a2eq0CMDoRbdd0FhXNmTKPmbdcIuaxuQ9em03BL34rsvyt3yvGziWaULlko72lNubCCH4CW09aG9xQKPI9VyYlYnqZqVpYMqY2GtyvRH1sSPQ90l4bTRGufp7D9NZaPi6olZjrtvqJX1M6rq/pwEA+10qkZcqGiaNSkzGQ+3VQoksxpr5Y5zQftXGMZlxFxiwfUxs+/qlp0IEV88uU4Wo91WuBFyzzRCNaX3rxsy6wIZf+2fBrAyP9mp4VYyehI/hoDk6vE80/kwEVvWEnF61szmtWB4lap9lgaj7oaodJTnzSkOenr+nSPAdZWu7MA+nHZGNkfNN6MvGQZaA3/gWm6o4OoHS5mh2p8Kkp+EWZi9T3eOOeHYEotCiqqY4qwuYvw9LZAC84U9TBisqLQz7XDotfYKm9sDbQpnnLmOzdpQ+hnzOHaJE180o7Fr2BxjzliJXnzXs4pnooR7jaKJlObTHPGbyIeWEKD3gB8YIzZWMH65PnzbTwfHmeLAsdfcp1zoq1szDpl0AHLtKXBvNLBxNsjLQR5HE17aa+dUAg1/Qa07rEeqvnpo2ONmLSh37MgKsNXHqSsVnXTAZR85/70s5P6w47c6aR9UjrnXaK/Foe0SfTy1+1TGVM06lMXV7Ue5/Me54Hj8G0aplr2TK0PrHMeW3x/EwBpZaLDqi0rfg5NNm58KRN3lcTwgzXzAAin8blb2g0GSKOPJkeU7poMjJcohPwoje9iI8/Z6GaNj85mjI5I9PxQflyLiDysIQpkzMZDDbyTIumXyuJ/M+OlLMIHRFqYx9NN3hMhokenpfMzWQc2EjphWoyhJpv3IfoEc+Z+4nWP+uMKZNi/dCbwCZ6ovFAG2GeD/OFaYrG74MFIpquaFmrXuN8j3ZUmibTvNhJcZTP/NOO0jRPHaCZjLHpJKkpIOU5sgw5iwPMbx0Ph8MRASU7XqZFy5v5x+uQ++Z22tFqe6DB/OeEgPvTX83OVQ+TTvF8eB4/h1/lXHTkriNPIUZH7yZF1B5ep8dA44eu5F59DyuAyQmwMxDl0Ne572jj8W/ehJP2XJ7Tjsm078BjmeYijorH1XTpfR3hi54L81/LhucmtPE1HV0Lvfq4tB5f18U1L6MZSdPC1LI0zRlARDZs6tc0Hw3hqy6ncT/auXMkz21NDlpHltqYaj3gbEz3zXqjN16jzVPTycGRLnNq/pqCNflcy4wNojb4+pruT//WPNIORjsLbus4jb9Ai3ksJ7Z04MLtNE1aJ3TQonnNWaTYORnbZLQ1//U2Ac9ZV0rEDood5oCDeaJtH/chMFWhfg6/qCzGA/JZblMEwYyTa7qdHKWTiEFvoHFGwF9FrI2lBhs400YkL9JoyirtOKo39cM1YqFPFqn0K7/5ZZYHUwiBKRPRUaE2tJq+gymDXpRcZ2W6hE88J9PCAho/tyHGjnmuDYXmkykr0XIRQxEN0frTesiGTmcmQq+MeTA+6iDL5GA0fdpY6c+iGSutN3wfZx86IzTJi/WOy77aGegMwKRvTIMpC9HG0+SgTE5Vf856qqGDMJEr722wLrGu69JWNGei15hp/4XHZ75wJqIzJJOstMykT94X0Z8JXcIPsUccBJramuYq9kpvgTQFTXYudXV18Pv9ESUcgY4QxBnIZjcvEN2OHYgwWwwSp5qcqrORM0VWOkrUxkxHEUInv7aeFUk/xMfjcaTHMEUG/CS+3geQ8U1Pz/O8eTHw+ID5Db8meuR/PmvPPNXyZHlrw6X5zPRqx6xlYbpmihx5Hhx4cCbG7XUkpp2oQG/mMq9MZSS9KIWH2pEKdJSvDbGeG1/TWR4bVBMdmkcyP/7fBL0mmL/CR/2ldTo75b5MzlzPn7OiaGuUM0BTVq0dEdOgj2FzwKr5zvrGgYSpTKfXpWmtCg26IsOGXK99GZ+P/jIvTYGFDtRZNgdbbzpI+zndZPui9e7n4HFMvVpYWFhYWPwbMH+hh4WFhYWFxb8B61wsLCwsLJod1rlYWFhYWDQ7rHOxsLCwsGh2WOdiYWFhYdHssM7FwsLCwqLZYZ2LhYWFhUWzwzoXCwsLC4tmh3UuFhYWFhbNDutcLCwsLCyaHda5WFhYWFg0O6xzsbCwsLBodljnYmFhYWHR7LDOxcLCwsKi2WGdi4WFhYVFs8M6FwsLCwuLZod1LhYWFhYWzQ7rXCwsLCwsmh3WuVhYWFhYNDusc7GwsLCwaHZY52JhYWFh0eywzsXCwsLCotlhnYuFhYWFRbPDOhcLCwsLi2aHdS4WFhYWFs0O61wsLCwsLJod1rlYWFhYWDQ7rHOxsLCwsGh2WOdiYWFhYdHssM7FwsLCwqLZYZ2LhYWFhUWzwzoXCwsLC4tmh3UuFhYWFhbNDutcLCwsLCyaHda5WFhYWFg0O6xzsbCwsLBodljnYmFhYWHR7LDOxcLCwsKi2WGdi4WFhYVFs8M6FwsLCwuLZod1LhYWFhYWzQ7rXCwsLCwsmh3WuVhYWFhYNDusc7GwsLCwaHZY52JhYWFh0eywzsXCwsLCotlhnYuFhYWFRbPDOhcLCwsLi2aHdS4WFhYWFs0O61wsLCwsLJod1rlYWFhYWDQ7rHOxsLCwsGh2WOdiYWFhYdHssM7FwsLCwqLZYZ2LhYWFhUWzwzoXCwsLC4tmh3UuFhYWFhbNDutcLCwsLCyaHda5WFhYWFg0O6xzsbCwsLBodljnYmFhYWHR7LDOxcLCwsKi2WGdi4WFhYVFs8M6FwsLCwuLZod1LhYWFhYWzQ7rXCwsLCwsmh3WuVhYWFhYNDusc7GwsLCwaHZY52JhYWFh0eywzsXCwsLCotlhnYuFhYWFRbPDOhcLCwsLi2aHdS4WFhYWFs0O61wsLCwsLJod1rlYWFhYWDQ7rHOxsLCwsGh2WOdiYWFhYdHssM7FwsLCwqLZYZ2LhYWFhUWzwzoXCwsLC4tmh3UuFhYWFhbNDutcLCwsLCyaHda5WFhYWFg0O6xzsbCwsLBodljnYmFhYWHR7LDOxcLCwsKi2WGdi4WFhYVFs8M6FwsLCwuLZod1LhYWFhYWzQ7rXCwsLCwsmh3WuVhYWFhYNDusc7GwsLCwaHZY52JhYWFh0eywzsXCwsLCotlhnYuFhYWFRbPDOhcLCwsLi2aHdS4WFhYWFs0O61wsLCwsLJod1rlYWFhYWDQ7rHOxsLCwsGh2WOdiYWFhYdHssM7FwsLCwqLZYZ2LhYWFhUWzwzoXCwsLC4tmh3UuFhYWFhbNDutcLCwsLCyaHda5WFhYWFg0O6xzsbCwsLBodljnYmFhYWHR7LDOxcLCwsKi2WGdi4WFhYVFs8M6FwsLCwuLZod1LhYWFhYWzQ7rXCwsLCwsmh3WuVhYWFhYNDusc7GwsLCwaHZY52JhYWFh0eywzsXi/zTOP/98dOjQ4bcm42cRDAbx17/+Fbm5ufB6vTjllFMAAFVVVbj44ovRunVreDweXH311di2bRs8Hg+mTZv2m9JsYXEwWOdi0WyYNm0aPB6P++P3+5GTk4Pzzz8fBQUFvzV5vykmTJgAj8eDG264wfj5Cy+8gAceeABnnHEGXnrpJfzlL38BAEyZMgXTpk3DH//4R7zyyiuYNGnSf5NsC4tfDY/jOM5vTYTF/w1MmzYNF1xwAe6880507NgRdXV1WLhwIaZNm4YOHTpg1apViI+P/6/SdP755+PLL7/Etm3b/qvjMioqKtCqVSu0bt0aoVAI27dvh8fjiWhz1lln4ZtvvsHOnTsjrh9++OHw+/345ptv3GuO4yAQCCAmJgY+n++/MgcLi18Km7lYNDuOP/54nHPOObj44ovx3HPP4brrrsPmzZsxZ86c35q03wRvvfUWQqEQXnjhBezYsQNff/11ozZ79+5Fenp6k657PB7Ex8dbx2Lxu4Z1Lhb/cQwfPhwAsHnzZgBAfX09/v73v2PAgAFIS0tDUlIShg8fji+++CLiPtlbmDp1Kp555hl07twZcXFxGDRoEBYvXtxonNmzZ6N3796Ij49H79698c477xjpqa6uxrXXXovc3FzExcUhPz8fU6dOhU7iPR4PrrjiCsyaNQs9e/ZEQkIChgwZgpUrVwIA/vWvf6FLly6Ij4/HyJEjo2ZHM2bMwDHHHINRo0ahR48emDFjRqM5fvHFF1i9erVbUvzyyy/h8XiwdetWfPDBB+71bdu2Gfdczj//fCQnJ6OgoACnnHIKkpOTkZWVheuuuw6hUCiCnnA4jEceeQS9evVCfHw8WrVqhcsuuwylpaVG+i0sfhUcC4tmwosvvugAcBYvXhxx/fHHH3cAOE899ZTjOI6zb98+p02bNs4111zjPPXUU87999/v5OfnOzExMc6PP/7o3rd161YHgHPooYc6Xbp0cf7xj384999/v5OZmem0a9fOqa+vd9t+8sknjtfrdXr37u089NBDzs033+ykpaU5vXr1ctq3b++2C4fDzlFHHeV4PB7n4osvdh5//HFn7NixDgDn6quvjqAbgNO3b18nNzfXue+++5z77rvPSUtLc/Ly8pzHH3/c6dmzp/Pggw86t9xyixMbG+uMGjWqEU8KCgocr9frvPLKK47jOM6dd97pZGRkOIFAwHEcx6mqqnJeeeUVp3v37k67du2cV155xXnllVec3bt3O6+88oqTmZnp9OvXz71eVVXl8uXFF190xznvvPOc+Ph4p1evXs6FF17oPPXUU87pp5/uAHCefPLJCJouvvhix+/3O5dcconz9NNPOzfccIOTlJTkDBo0KIKnFhb/DqxzsWg2iHOZN2+es2/fPmfHjh3Om2++6WRlZTlxcXHOjh07HMdxnGAw6BpXQWlpqdOqVSvnwgsvdK+JEW3ZsqVTUlLiXn/33XcdAM57773nXuvXr5/Tpk0bp6yszL326aefOgAinMvs2bMdAM7dd98dMf4ZZ5zheDweZ9OmTe41AE5cXJyzdetW99q//vUvB4DTunVrp6Kiwr1+4403OgAi2jqO40ydOtVJSEhw227YsMEB4LzzzjsR7Y488kinV69ejXjavn1758QTT4y4Fs25AHDuvPPOiLaHHnqoM2DAAPf/+fPnOwCcGTNmRLT7+OOPjdctLH4tbFnMotlx9NFHIysrC7m5uTjjjDOQlJSEOXPmoF27dgAAn8+H2NhYAPtLNCUlJQgGgxg4cCB++OGHRv2deeaZyMjIcP+XMtuWLVsAAIWFhVi2bBnOO+88pKWlue2OOeYY9OzZM6KvDz/8ED6fD1dddVXE9WuvvRaO4+Cjjz6KuD569OiIo8yHHXYYAOD0009HSkpKo+tCk2DGjBk48cQT3bZdu3bFgAEDIkpjzYnLL7884v/hw4dH0DRr1iykpaXhmGOOQVFRkfszYMAAJCcnNypNWlj8Wvh/awIs/u/hiSeeQLdu3VBeXo4XXngBX3/9NeLi4iLavPTSS3jwwQexbt06NDQ0uNc7duzYqL+8vLyI/8XRyB7B9u3bAew33Br5+fkRDmv79u1o27ZthGMAgB49ekT0FW1scV65ubnG67xvsXbtWvz4448499xzsWnTJvf6yJEj8cQTT6CiogKpqamNaP61iI+PR1ZWVsS1jIyMCJo2btyI8vJyZGdnG/vYu3dvs9Fj8f83rHOxaHYMHjwYAwcOBACccsopOOKIIzBx4kSsX78eycnJmD59Os4//3yccsopuP7665GdnQ2fz4d7773X3fRnRDsV5fwXTtFHG7spNE2fPh0A8Je//MV9boXx1ltv4YILLmgGKg9OEyMcDiM7Oztq5qSdk4XFr4V1Lhb/UYjTGDVqFB5//HH87W9/w5tvvolOnTrh7bffjnje47bbbvtVY7Rv3x7A/qhcY/369Y3azps3D5WVlRHZy7p16yL6+nfhOA5mzpyJUaNGYfLkyY0+v+uuuzBjxoxmdS5NQefOnTFv3jwMGzYMCQkJ/9WxLf7/gt1zsfiPY+TIkRg8eDAeeeQR1NXVuRE2R/nff/89FixY8Kv6b9OmDfr164eXXnoJ5eXl7vW5c+dizZo1EW1POOEEhEIhPP744xHXH374YXg8Hhx//PG/igaNb7/9Ftu2bcMFF1yAM844o9HPmWeeiS+++AK7du1qlvGaigkTJiAUCuGuu+5q9FkwGERZWdl/lR6L/7uwzsXiv4Lrr78ee/bswbRp03DSSSdhy5YtOPXUU/HMM8/gxhtvxJgxYxptvv8S3HvvvdizZw+OOOIIPPzww7j11lsxfvx49OrVK6Ld2LFjMWrUKNx888247LLL8OSTT+KUU07B66+/jj//+c/o3LnzvztVAPs38n0+H0488UTj5+PGjUM4HMZrr73WLOM1FUceeSQuu+wy3HvvvTjhhBPwyCOP4IknnsDVV1/tZnUWFs0B61ws/is47bTT0LlzZ0ydOhXnnnsupkyZguXLl+Oqq67CJ598gunTp7v7NL8GY8aMwaxZsxAKhXDjjTfi7bffxosvvtioT6/Xizlz5uDqq6/G+++/j6uvvhpr1qzBAw88gIceeujfnSYAoKGhAbNmzcLQoUPRokULY5vevXujY8eO7r7MfxNPP/00nnnmGezduxc33XQTbrzxRnz++ec455xzMGzYsP86PRb/N2HfLWZhYWFh0eywmYuFhYWFRbPDOhcLCwsLi2aHdS4WFhYWFs0O61wsLCwsLJod1rlYWFhYWDQ7rHOxsLCwsGh2WOdiYWFhYdHs+D/5bjHHcRAOh+H1HvCd/A4rfrQnFAoZ2+nvOD/YWPy3x+OBs/97chp9Fg6H3eter9dtK2NpmnW/Qq/H44HP54PjOO7/8iNtvV4vwuEwQqEQgsEgHMeB3++PGF9o8Hg8CIfDAOCOL+1kXJmL4zgIBoPu/TIOg+chn8n8/X4/PB6PS5fQILTJZ6Wlpbj99tsjeKplZKKTaeH7eN4ffPABioqKmiRfCwuLxmjK45H/5x6iZGPCRsjkXMLhMMLhsGuoHceJeLNsUxwM9yXGS64LDTKOvs/kFLgf/puNvHZacq/P50M4HG7kXEKhkDs3dj5erzeCZgDuV+IKTTK29CFzkc9iYmJcOqQ/cdhMq/wWGuQ1+z6fDz6fL2IMAPD7D8Q9Mhehm+Ujc5Tx5H89B+bBhg0bUFlZ6V5nmesgQPqRsRoaGlxnqMfy+/2499573dfWc6Ci+cAw6Zl2qI7jYM2aNQgGg43aWlj8t/H/rXPRCzMaQqGQG2Wz0QWanrnImGKU2MhzJK6dHTsFNkJisNgwcsYBHHBkes7sPDweD4LBoGv8xLlJ5qDpBxDh0KQv+VycsPBM+kxISIjIfNjYm/jETo+dnLQXerUjNDkXdgQM/s54lq/8xMTERGRUHFzwDzt9uVZfXw+v1+vyQhAMBuH3++Hz+Vwa5W/pPxwOu86B+xQHyw5QZ8DhcBivv/46ampqIuamM+1o+s/9aMc5Z84c45e0NQcCgUAEnyz+b+D/S+eiEW16nE1I9CpOgZ1NNCcTrV+dFUlfpnbBYNA1JGI4g8FghMH0+XxuFC9GgRcrGwrpS4yxGHE2KjExMREGScpTANwshLMvppWdnNARFxcXMcdgMOjOS+jRvBHHwg5Psgf5TOjQZS/O9nRwIJ9zlshOXmgWB8tteV4CNvAmoyz36TkKj8WxyN8yvjgFLTtTX9pxc59SVmRaTeVB0QeRjZ5jTU0N6urqInjAQQDPVwIBDpg4ONF6+frrr2PdunUHDda0jOWa7k/P8csvv7RfbvYbwToXgp4mlxc449ARJXBg4eo9EV6I0o+0kcXHWQXfw85Nl8fEAPn9/oh9EenTZIB5P4MNjJSfpDzm8XgQExPj0iMGB9jvXHRUztExGzu57vf7XecsfODonPeWmPfasMbExEQ4H7nOWRPzSvqReZscOf/NhpKdnvDTtPemDay0kf95v4mdY1xcXMQektYroZuNKc9P088Bi8hJ5BAtS9d7T7pEatIfneWyzmvDLjJk/dQZIus3O0XtWLUDE13nMq/Qw3SvX7/eLW9yP5wJS3/auXFGCex/2ajc980332DWrFmNeGoKLKIhmjPdt28f9u3bF/W+/xX8V52LqZumlJZ+7X2/FNrosOLzxjIbKFMJRu9/8OfSRhYzOx92LrxvwX2Y+uZ9kYaGBrd/XmQyD+3MwuEw6uvrASBiTK/Xi9jYWNeJcWYSGxsbYbjYoTKf9D6HOC12guKguT+hRZyezIX3WMSZcHttxOrr6yMMO0e2HNmzYRaDJf1y+VFH8wBcp8X6IhkAl+h0RuH3+12n6ziOGySIcTeV8tgZMQ2cqbJD530iNs7RSmV8sIP1hHnBGSnrFLdjh8DORZdBpR9eA8IHPgjCZVbuQ+bBB1a4L11dkM+FHnYczA9eY9q58P0sIw6o9BrVma8OXDjoCofDWLp0KRYvXtxoHbNc9B4gl6uFnqVLl+Ltt9/Gb4WmuI1mPS3Gk9eC/TnoSK45HIzJYLBC8gKQz3iBs9GJts8hf7OhYsg1iYy0Y9PttLHj8XUExkZenAkbQW7D9IbDYfdLu7SBZEPBDkDTxoZIR+ZMg16w2oBw1Kn3uzhDY9nw3MQx6pNvbCS5NMW84X6Yv7qUxkZN+pR5sqykhCmOQsYQA8o/LFs2ojyWbsOlNaBx2VDrjMkAcNAistPZhjak0j/zj++Rfk2GknnJfNMGXAdTej7sPPga9y9rwMQvNtrym9tKMKB5znPUGZJp/ev79Frp168f+vXr10inuZ0EWnrdsVySkpJ+U+fSFPzHjiL/EgdjitiaC6boRZRUTv5omnUEKP3wwtDtWNFNewBsZOW6LsXI/+wQ2ADruXD9XpyXpplp4z54QXBGwOVC7Qj1Jnw0o6GNml4gAv2d79p5sBHVhkvvQ5mcmo6omTe6bGRyWmzIuV/JrNh4Cp0mWXGWx/OUPsUo8kEQ6U/zx8RLk+6xvE3GjsfXhzTEUPP/mncclElkrcuSzH+mQa8X+THt62kHwutBB2k6eNG0yDXdB/NIslLu02Q72OkID7QtkXacQZtokjHlc15n3E7L8feOZnUu2tM31VGwQdIK0hw0AY2jOKaThWmKVgE0WrQ6gmIF0BEu08FKwyUvWbCxsbGNoj3hCRtv0w8vWjYKWhnFMMTExLgb3PKbMyAxMiajyIuUP9cLn/nGdOjoUJffZGyeD+/LcAagja028Fru7CT0nFgPTAba1JeAnS7rjy5HMY80P5l3Jr2Sz7VMmFaW388ZIZNcmCc6u5F5at7zvfI3l3NMgdjB5s10R3OkzBfTfhvLzZRVcdmOeannoulhmQttWl81f0280gG1jMmy42xM7xP93tHsmYuUKHRUejCEw2FUVFQgKSnJPbHUHNDRkv6MN4LlhJPp2K/uS6CFzIaQr5kcgqZReCa1X47SND18j/Sh6TGVHvT/0qa+vh7BYBAJCQkA0CgqZSOnN1rlNxt0Tt/ZuOho1VS/lt/RntkRx808Nsna5IhNUShni0wPBwcm48un7MS4sWERHmhemwyMzlbYWTLf5G+9j8XBDBttzqS0o2QHofWRx4qmu3y/9KFLe9GyJw4SBBzl8+GIaIEC64DsEzJtAna0Wk9MctUyZ91nHeU1xfM37dkwj0w2Qztrnq8pAGlq0P5bo8kpQjAYRH19PWpra1FTU9MoGgP2n2n//vvvUVJSYuxDC1UE8tlnn2H8+PF48803jQKIdn80RGujlYONs05DZT9CLzBesIA5g9GKAhxQcvmRzV2G3rjj0pNWKqGJN8KFDgEf1WW6xInqKDsYDLr7LBI1cXqvDbq00XziufMiYWMohlk7flP0qBc5y4jLOkIjOwZt7PSi5z51QCQy0se5tf5qvjDvWX7cnzYa0j8fRddzC4VCbvDB0FkAOxq5r76+PmIe0YykbsN9i0Nlmph2aaP3+LRD5TXA40u7hoYGN+CJRg/rHeuZ1j2TPgqtOqvWv6W90CE2z9S/zJ3pMDkjLW+mT/ct+sCyl9OdJp37vaHJzqWhoQGBQACLFy/GH//4RyxfvryREa+trcWXX36JzZs3G5kJNN4M3LZtG26//XZ4vV58+umnCAQCxvFNzqSp17TAeNGyI9BZgv5bEG1h8hjaCOnSTTQDx32Yxo2m2KZ7tbGS7EgcJC9QMfgNDQ0RR57ZccjY+lkcnhs7AnaSOsLjzEGiVVNZiQ2hdhRc1jAZOs0Dbex0lCnt2BHokgfPTwcnWgcPRpf+TGjljAiIjNClDza+WheYzyJLuV8bP+28dD8m+rWO8/jaaWg5CM/ZWAvPOVhlmfMaZXnKfqmuFrCDi5Y96HkzfaY22hk7jtOoZCs80/eZ9FM7JB1MyDX5zetSy/v3jCY7l3A4jM2bN+Oaa67BK6+8giVLlrifsXHZsWMHSkpKojKAF2FDQwPee+89tG7dGn/7299QUlKC+vr6JqV9v5TB0Yy8LvmwwEWgWuAcpfDfukxgWpysxHw8WTsNjgC1E9EGVo+r++HP2WjwNc6aeMFxX/pBR15M2uHoebGD8Xq9EQ9z6lNJJv7pkprmNxsvfUhCGzqBtDXJWJyvZIbcD0excjpM2rExYqMhczJ9zk5P88Lj8UTwlp2ylq+pfKJPQ3LgEc3Z8We8sa/pZv1h+uV5K3ZU+oFa4MDbIpj3JmMuUbvJCUoGzjxg/rAeMM/4f76PHTvbCh6bH0Y1BTha9vKb5chjm3RFByuiiyY9/r2iyXsupaWleOqppxAKhZCTkxNR0pHJ1tfXY8eOHaisrARg3tBngVVXV+Pbb7/FWWedhTZt2qC6uho1NTVITU2NSgcbx6Y6If07HA5HRJ38P0d58rneO+C+TMaQ+9GHE9gIyrishPqEic/nizhFYzp5pGlhoyLG0+RAtJNhJZb+5F7taPge5p82/DIXfn8Y76HwdYE+FhoKhdw6vXYqplKhQG/ysry5jS47ssHhLEzva+j3nwGR5TDWAa2zJufO82EHwdfEUEeTPztHHTTp1/fweOxMpE9dttX8ZR1jGkz6wfPQ+qvba97InJhWfZqN9500v5h2MeTMb86a9L2sX+yY+e0ITLsOvFhG/Jkegx0p64MEQEy3puv3iiZnLv/85z9RWFiIm2++GT6fD6mpqY0YX1paCgDo379/IyPM7UTIO3fuRElJCYYOHYrk5GTExcWhtrb2oHTohd8UiGB0qs+LjPvmBWFqq+fDjocfdDRFWuxIuM3Bsg92FpyGa0XjtFovUG4jMBkPU2bDRkMboGj81qUBLQNNs5RKOCvQ7XQEyfwzyUPTwZkn963LdtH06mBRoxgcUwSu6WYZCk2a10yDGGP9qiDtGLgvaaONE8taxmO6tJMyrZFoPObPTHLV60BH71z6YcfI0T47E5a3ztB4ntqg60DIdAqP+a/fnmAKELg//RnzV5chmV8iaw6+ZJ/FpEe/dzQ5c5k/fz7uuusuxMbGori4GHV1daivr0dsbKw72bfeeguHH344unTpAuBAtFBfX+8ec2UDtm7dOiQmJiIlJQXl5eUADjy493P4NZ5bRyY66uNogxVS7wuYlIhPMYkzCAaDCAQCSExMbOTY2LCx4TVlOhz5VVVVwev1IiUlBV6vF4FAwD1hJ+PrkzwyL+E/v5FYR5WcrehFqst42omaInS9kLjsY3JSLAu9N6OzS6ZR6NAZo9d74M0GbJBNGWi0iFsbAZknZ17RDA3TzsdKmTeiO6xfnBXo7OzngiKWq46Ofy6AED3SusR66TgHykfsxKLxU37rjEocMvND+uRrQrPpRCfrE/Na6zTrpQ5YWIe0XeHPtTPkObNT0OuGnTaPI3OT+3kNsZ3SDlcHCr9XNDlzuffee9G/f3+UlZXBcRy8+uqr2Llzp8vI3bt349lnn0VSUpJ7jzApNja20esqHMdBYWEhMjIyEBsb65YYtHH9OfAiPtgC5/+14EwOhennqE7acZSoIx8R/vfff4/zzz8fa9asaUR3OBxGIBBAcXGx0eFJG67TBoNBTJ8+HTNmzIigj0tI8r8pQpJ2/FJJvcB0ZqAjbd1GZ0s8B3ay8hNto1UbPzaCAulLy5fvN8lbtzNlNCYd0u20XgAw0sP98Fy10dF9aT1jJ8P9mxweGzAeW+YQ7WTVwfgoPOcIWstanxrVNGlox8JrRgckwIGsUpcvTXZC6ypnNFp+rEvaOen9Vc0jzqTq6+vdE3wmWfL+jolu4a3eQ2Onw/39L6HJlnzgwIEIBoPYsGEDgsEgRo8ejby8PDjO/lMp+/btQ1VVFVq0aAGg8QNgAhFQXV0dtm7dihYtWsDrPfCuqKY+H6MXimkBR2tvynq0wdOGgCNoHQkJuO5eVlaGF198EStXrsTUqVMjol65f8WKFXj//ffdp+tlXJMiywmh0tJStGzZMoI2VkrtVIQekxPho5XasGlapD3vO7CB0A6HF6qWTzTHpKNKHscUBEhGYpIzGziddWk6xQmaDCPTxnRJHw0NDRFHRKUfPqGm72Va+X1bLAetd9pw8Ry1vKI5TeY1f8bOg4+5akPJ8med1zLSzko7dH5ZKmdiLA9tXHm/QhyDyJXtjK4scL/RftiY6zIU96UzokAggLKyMhQUFKC2tjZC3gcLHoQmDrzYQQmPdKaj+/u9o8llsXA4jJqaGnz22WeIj4/H4MGDIzYICwsLERsbi5ycHADmzTT5KSoqcktFdXV1CAaDKCkpQVlZWZMfouRFpGvS2jhz1KCf+eBUljcNdRTFwjVFPNw2FAph2bJlKCwsxFlnnYWffvrJXZS8uH/44Qds374dMTExrjLpDIkj+m3btuHTTz/FwIED3f702XumS8bTJSWep8yJ5cyvNuE2zBs2bKaFLH/zOFzO0KW3+vp6xMXFGeXLESu/IkXmxZu5Ap6zXty69KBlLP9rw2YKPvjEk4zFRpgf1DWVarhfHRjxmtHlN5Mc9TrTp+a0o9cO2MQLTQ/3x2PwXLRD5YBRv/Jf6BZbosuBbIx1CUx4wHORcVk3GDw/diCsK6z7plKe4+wv9QcCAaxatQoxMTFo1aqVKw+WFWdmvK6Zft03Bzw66PR4PKioqMATTzzRSD6/NzQ5c/H5fCgoKMCmTZtw8sknY+jQoQc68Xqxbds2ZGZmol27dhHKBUQukvXr1+PGG2/Evn37EBcX53750datW+HxeJCSktJk4nUEalI67Sx07Vj3JW31oteKquvjulywdOlSdOzYMcJpcOrb0NCA0tJSY/nApGyO42Djxo0oKipChw4dIuhlQ6yvS4Qv47Ky8w/PQTIC7Vy0s+DPdHRq0gEdGetFa8oetBz03DQPmIfaoOt79DWTcee+WdYCU8apa/M6mpX2rC86i9Njs3y0Y4+2DiQy1mtB6zrrhkk/dMlTZygiW5Meczutnzw/Dh7YqXAgwvdoh8yZlc4KTBmVgOfL89R7TjojDYfDWLt2LZ544gnEx8dHnByUsaVffh6JMzctf+lbr1NdhgwGg+7hqd8zmuxcHGf/A49erxe33XYb4uLiXKNVX1+Pb7/9FikpKWjRokWEwFkBHWd/KeiLL75AKBRCXV0dYmJi4Pf7UVBQgN69eyMxMdEdz7S4TVEA0Lg2KYLg16nozIDH0SUH6dOU0uqxeYEA+5Vr27Zt6NevH8rLyzF06NBGR59FaaSswnRooy5Hc3fv3o2//e1v6NKlS9SFzVGPpPgA3LKjOMTKykosX74c8+bNQ1FRERzHQVlZGXbs2OGOzYZH5qWjPdmols+ZJuGT8JEXPPNTl620kYvGb+GVzt7EsYgOasfLP9wvZ6S6JMFGgrMnrafsXNm5yfw5cGFHxfyRa3wAhteTLrmZ5sVGyRTAmHiq14Xp9BvToefLsuH+9P3a8ck6FX3VffN9rBd8vy65cSBjciimPjVvNI9k/ci1jRs3Yu/evWjZsmUEv3gtc1Aqc+LgTdrK3GX/heek15bJSf4e0eSy2J49e/DPf/4Thx12GDweD9avX48dO3a432C3detWpKWlRTgH+c0GZ/fu3WjXrh2SkpIQCATc7GXTpk3o1q1bxAkMU5TJn7GhZqPMZQz+zHSKiqGFZoq8dRlE3x8Oh1FZWYlly5Zh4MCBKCsrQ+/evSMWmiAlJQU//fRT1CxPlDMUCuG1117Dq6++ikceeQR+vz9iI5kzKD2G8KK6uho7duzA2rVrsXr1avz444/IyclBhw4dUFxcjNNOOw3Tp09HfX09rrrqKsTHx0eUoxoaGtxnbhzHicjc+KSciZ/agAkvOO3XGYCp5MP6oEsm4XA44isEdMbKfWgaZcHv3r0b8fHxyMrKapThckQpzoVPSXG2ImAnI89FsIPXRouvR6ObAxAOltjwsU4wT9mZ68+Y/8xTzWuTYWNH6fF4Ip5J0m0lk9frTJc2dTbJWazenzJt7nO5m+2AaY0zPXr/j/c+WIY1NTVYu3Ytevfu7VZbRD+ktM9OlIMMU/bPMhVo28XVgf8FNNm5TJs2DT/++COKi4txySWXuO8Y69SpE2JjY7Fq1SoceeSRrpDECy9fvhyhUAgDBgwAAFRUVKB9+/aIiYlBWloatmzZgsrKSqxZswajR49upOQCjvp0dM+CkT2cxMREhEIhFBcXIy0tLeLbFU3RoMkAchtWMlZAMbQcTdXX16OoqAgbN27E8uXLkZGR4Sqm3OPxeCKOcbPic5tweP8Xfi1btgwxMTFo3759hEEB9tf1+Qh3IBDAmjVrUFdXh+rqaixatAibNm3Ctm3bEBMTgzFjxuC6665D//79ERsbi4aGBlRXV+O7777D+PHjI15nz8rMUZ7+/hi9YNmIRssWtVPQ2SMbTz7Gq2WkjRBnU0w3gEbX5f5gMIgXX3wRJ5xwQsShFD0/iTL1sWhpL30Kz0zfsMnf9yLXeD9Ql5N4zmxI2dhpw8Rz5mt67qZ1oB2z1numhfusqKjAM888gxNPPBF9+/aNkBvLPNpJL02/XhPsILSziHbKlPlr4gM7UP6tnTGvAXGka9asQd++fd09Uwk8deVBB7ba0bD8tHPRGSrT+HtHk53L559/jvj4ePTr1w8nnngihg8fjuTkZCQlJWHz5s3YsGEDzj77bCQlJbkvuJwzZw5uuukmnHLKKejXrx9CoRAWLlyIli1bugIqLS3F9u3b4fF4cMghh7jj8SL2ePa/uXfdunVo1aoVWrdu7SouG3bJGvx+P2pqarBmzRp88sknOPfcc5GbmxtRbmCFlKhJrpkMBhtJVhgdbXIEt3DhQgwdOhTZ2dkRabvcFwwGUVtbG1Fu4cUjY1VWVmLz5s047rjjkJaWZqzNS38+nw+VlZV46KGHsHv3brRs2RKZmZk47bTTcMghh2Dt2rWYO3cu2rVrB6/X6xq6rVu3oqamBj169HCNLc+tqqoK77//Prp3745evXpFvDVAeM//M/SGOC8aHYWygRY90D9yPRQ68IZmjg71l0Jpg8jX2Dhv3rwZVVVVbpamHavH44mYo34GRY/FOiS/+dkeOSUJHHjan+fPc+X+5bfX63XLKUILP7muHbA+SaX/lnmbDkjINd7g1tnlunXr8P7776Nz58449NBD3dKU1+tFbW0tSkpKkJaWhqSkpEbZi/Slecr0MW9YZzhAMbWXNjIH/SoakbOsS54/O23RsVAohIqKCtTV1SE1NdV9K7OsPwbv0XB//O2p3L/+qnIO1vVzUr93/KLXv/Tr1w9PP/00kpOTIxbYzp07sXnzZmRlZSEYDKKyshJz5szBAw88gKOOOgrXX389SkpKMGvWLPzwww8YOnSoG7kXFhbi1VdfxdChQ5GTk+N6ct4rCYVCmD59Ou6++25cfvnluO666yJSTzZWKSkpCIfDWLJkCR588EFMnDgRWVlZqKurw/bt2xEfH4927dq58xIjxYuRFyULVBaL0M59AAe+b0Gcxq5du/D3v/+90Z6E1FMDgQBqa2sbGT2O9MPhMPbs2YOVK1fiiiuuMG74ysIQHqSnp2Pq1Kmoq6tDQkIC4uLikJCQgLKyMtx5552YMGEChgwZEnHab926ddizZ4/LP+G7LPa4uDh8+eWXaGhoQPfu3SPKQNpIa8fAWYyO2PW+Ahst3ZcYC3ZWgUAAwWAQe/bswYYNG1BdXY3NmzcjJycH+fn5OPzwwyOMizY6TH9DQwOqqqoQDu9/BklOerGh1VkSZ8P6gIJk0suWLcPOnTtx0kknITExMULW+rQiByzSj3Yuck9tbS22bNmCL774AmvWrEHnzp0xevRo9OjRo5Ej07wUfeU5ybiin/oEFW9uc4Qugc3333+PqqoqxMXFufohDmn37t148MEHMXr0aJx66qlGx2kyqvw5tzHphXb4/D+vcd2//C3OVWe3Mi5nnEVFRQgGg2jbti3i4uIaOXPhk+Ps35MuKSnBsmXLMGjQILRs2bKRs2FdZMergy+tD79nNNm5rF27FpMmTUJGRkaEEZGSSiAQQENDA7799lu88sor+OSTT3DaaafhrrvuguM4uOOOOxAXF4eTTjoJCxcuhMfjQdu2bbFp0yZUVlbiqaeecpW7vr7edQYtW7ZEixYt0LNnT9d4c/1RfkThfT4famtrMXPmTKSlpeGoo46Cx7P/O6fvu+8+pKWlYerUqe4mHLBfwEVFRSgpKUFJSQleffVV9OvXD2eeeSaSk5MRDoexdetWTJs2DXv37gUAjB49GieffDLi4uIijJbXu//76b1eL/r27YtevXpFKHtDQwO2b9+Od955BzU1NUhMTIzYK2DFkbmVlZUhNTUVeXl5EaUQUxlGlC8tLQ3p6enumMFgEJs3b0YoFMLQoUPRokWLiI1wmZeUE2NiYiIU2e/3Y/z48di0aVNESUwbIYEp+5A2XFYU+rgsxI6Io1QxVnK9oaEBa9asweuvv46dO3ciLi4OixYtQu/evVFaWorXXnsNV155JQYNGoS0tDSXTpm33gMJBALYs2dPhJFlpycZkuMcOGTBCz8+Pt7VX5HPnj17cOedd2LcuHEoKytDQkJChL7KfNnIsFM2Rary5odFixZhypQpGDNmDC688ELXcdXV1SEuLi7iBZK6bGbKPJjnoktA5LvRpB33J+0aGhqQlpaGNm3aRBwyaWhowNq1a7F+/Xr8+c9/jqgSsF5wf3o81i+dkTGfmH5dttNBAq85uUfetsxBDM9fss0tW7agtrYWHTp0iMj42KnIXOQRjo8//hh9+vRxKwZ8qkw7TZmvXgM64/s9o8nOJSYmBj179gQQuQEXCoVcL/7EE0+grq4OmzZtQseOHXHTTTfB5/Ph/vvvR3l5Oe6//3589tln+PLLL1FYWIjOnTsjIyMD+fn57vvI5NX+Tz75JP7xj3/g6KOPxgMPPIC4uDh06tQJJ598csTi09FCOBzGwoULsXTpUjz22GOIj4/H+vXr8cQTT2DChAl44oknsHPnTqSlpSE2NhbBYBBlZWW49tprsWPHDowZMwYjRozA008/jcGDB6N79+6orKzErbfeipYtW+Lss8/Gtm3bMGPGDIwYMQJt27Zt5OgAICkpyd3TEBqDwSCWLFni8iUYDKJ79+5oaGho9IVHwIHjzl6vF506dUJmZmaE4gMHok/OQiTKEn7Kgvjuu+/Qpk0btGvXLiJyr6+vx8aNGxEKhXDjjTciOTkZZ511Fg455JCItFyMdG1trfs6H/0Mg2kjnKHlxrSLHPlYJy8oWdzStqSkBM8++yyys7Nx2223ITU1FZMmTcKZZ56JsWPHory8HNu2bcPUqVMxdOhQHH/88Y2+Slj63b17N9LT03Haaae51/lzWfRLly7Fu+++i6uvvhpZWVmuw+G2bDyLi4uxZcsWDBw4EFlZWRHyDQaD7jePcnbF5RWWMzu3H3/8Effddx/OO+88N8hhmrWj0utEwO2Axs+TmDIehmR84XAY5eXlbkmc+REOh7Fo0SKcdtppyMvLc8dnBytjm7IX1gWWhek0nT6Rpx2WLhsyHTIGv5mdy+6cHe3ZswehUMjdszTRIzIOBAKYN28e+vfv7z4ArTN/U0bGMjI52987mnwUuXv37ujWrVuEwRDF3L59Ow499FBce+21uP/++9G/f38MHDgQ5eXluPrqq7F9+3bcc889yMjIwIABA5CdnY0vv/wSwH5GderUCSkpKW7ZqaKiAl9//TWuvfZabN68Gc8++yxeeuklHHXUUejYsWPE6SRmtNfrRXl5OaZNm4Y//vGP6NWrF/bs2YOnnnoKgwcPRu/evREIBDBr1iz89a9/RUlJiav4koGNHj0agwYNQosWLSIWgeM4+MMf/oCBAwdiwIABiI2Ndb8mWJRLfm/fvh1lZWXul6ZJlFhVVYXnn38eXbp0wTPPPIOxY8eioKCg0dFEzgpCoRAyMzMRHx/vRlUyFh/pFSPEJ5o46qqpqcGKFSuQkZHhPsDq8eyvE69duxbfffcdMjMzMW7cOGRlZeGOO+5w3/cmdPh8PvTp08ctSXKUxnRo5y9yZjnx/hIfTxbjzJGodkYyTjAYRFxcHCZPnozs7Gw3M2jbti0cx0Fqair69++PM888Ey+88AJWrFgRsai5PFlRUYGamhqXHj4yyrqWlJSE9evX49lnn0VJSYnrCHiPhh1+RUUF4uPj4fP5UF9fj/Xr1+Pdd9/F0qVLI54GF5j4qK9XVFTgxRdfxNFHH42TTz7ZdUh89JaPtfJ65X65jc4GeEw+YssZs/ThOPsfU1i3bh1qamrw4YcfRvC5vLwcy5YtQ6tWrRo9DKqPpusfrUeaLuafKWjgtaEzMA4GdQYh4D1Ux9mf3dbX16O+vh7x8fFuiUt4pA89hMP7X9C7adMm920kPBfWLw2hhz//P1kW69ChAzIzM93FxJFBWVkZxowZgyFDhqCqqgqpqan44osvsGzZMrRp0wYPPfQQWrVqhXA4jFatWmHs2LF46aWX3H0Aji58vv1f9SvPwJxwwgl44YUX0K9fP1x33XWuY2EFEDiOg02bNmHBggW4/vrrsWPHDrz11lvIzc3FaaedhmXLlqGgoABvvPEG0tPTsWLFCgwcOBAffvghNmzYgEmTJqFFixb48MMPkZSUhLZt26KhoQE7d+5EXV2dO//Vq1cjGAwiPj4eAFxl83g8qK2txbvvvos2bdpg/vz5qKqqctuVlpZi8eLFuP3225GXl+ceUeYfnov8zsvLw1lnnYW6ujqXP6YIzOv1RrzEUq4BQElJCTZv3oyLLrooYlO6rKwMU6dORYsWLfDoo4+ibdu26Nq1K5YsWYLCwkLs2bMHM2bMwLhx49C3b98I4xkO7/966pUrV6KoqAijR49GamoqwuGwm/Zz2UnkW1RUhD179iA/Pz/iYIDMSxwZjyNzZEecnp6OQw89FIFAAAkJCdizZw/8fj+ys7NdPng8HrRv3959rqd3794RCzkYDKKurs6VUWVlJTIyMlze6Ug+Pz8fL7zwAsrKyrBr1y6kp6e7bXlPTTLToqIi9OzZE8nJyXj++efxxRdfoKKiAqFQCDNnzkTLli0bZaxsUHl/Q/pfvHgxqqurceqpp7rtOEvVb/GVPtkpaAOo+SzQtPH/7KxWrVqF7du3Y/jw4Vi3bh22bt3qnmzctGkTUlJScMghh7j6IxkB98VGX2hm+vgBS9PJOq0vonf8tQ7MEx5H1gxnO+K0GxoaUFJSAr/f7+6v8HNj0pdUINihAcAPP/yApKQkdOvWzaVXZ1Ysc868WH5Ck8n2/R7RZOdy7LHHunsJwAFl9fl8OOecc5CZmQmv14vk5GTcdNNN+Prrr9GlSxcceuih7gEAn8+HmJgYXHLJJRgxYgQWLVqEU089FS+88AK++OIL92HDpKQk19jFxsaib9++ePLJJ91yjoyvI6xwOIzs7Gx07twZM2bMwPz58zF+/Hj84Q9/gN/vx+LFi5GcnIyHHnoIn3/+OXbs2IFDDjnEfVq+oKAA119/PbxeL/72t78hISEBNTU1eOutt9wSWENDA3788UeMGjUKVVVV+OKLL7B582a0b98ew4cPx5dffonS0lJcf/31uP/++7FkyRIcddRRcJz9p74klfZ6vRg6dCj69OmDb775Bn379kVWVlZEiY0N7PHHH99oIbJi82IV5ZRMyuPxYMeOHSgsLMSAAQMinPmWLVuwYcMG3HDDDcjOzkYwGERxcTEqKytRV1eHGTNmYOPGjXAcxy2TyQmniooK/P3vf0dpaSl8Ph+++eYb3HfffRHKz2UFNpRPPvkk/vrXv7p64/V6sX37dvck21FHHYWEhISIY9GctcXExCAmJgbDhg1zDyJUV1fD5/O5+1iBQAChUAj/+te/kJubi379+kUYsIqKCsybNw8//fQTVq1ahe+//x7XXHMNhg0bhlGjRqFjx44oLCzEokWLEAgEcMwxxyA9PR2pqanuwQd2nPX19e6XoInT/Pzzz1FVVYXnnnsOJSUluPXWW/Haa6+hpqYGycnJEY5D1pNAZxWO42DPnj147rnncPbZZyM7O9udC+sFH8Rgp8LRuTZsrFs6O5ExtOMRmisrK/Hdd9+he/fuuOSSS/Dggw/i3XffxVVXXYVgMIj58+cjOzsb2dnZ8Hg8CAQC8Hg87hsqWrVqhUAgEEGzzqS4nMcnrfiatgX19fWuzRG5iJPhgxickdXW1qKyshJ79+5F69atkZCQgK+++sr9Lqu2bdsiIyMD+/btc/WW5cWOTzKrvXv3Ij09HZ06dUJRURHq6+vd8qC81Jczdy4PSn/8RWH/5zKXs88+G3FxcY08bUxMDAYPHhzB5Ly8PJxzzjmNFovU05OTkzF48GAMGDAAFRUVKC0txb333ovc3Fz85S9/QZcuXTB27Fhs3rwZffv2xa233hqxt6EjKVaWnJwcTJ06Fffeey+uuuoqHH/88QiH95+4Kioqwg033IChQ4fi888/x8svv4ylS5fi+++/R3Z2NhYtWoSTTjoJJ598Mvx+P3788Uf89NNPaN++PcaNG4eYmBhUVla6x3Zvu+02xMfH48wzz0SfPn2wb98+7N69G1deeSWys7PRtm1bzJo1CxkZGaioqEB1dTWA/Q+krl69GitWrMA333yDrl27uqe3OEJhIyH81dkAGwMAbtYgn4kjWLJkCQ455BDk5OQgJiYGgUAAjuPg/fffh9/vx+DBg92N/HXr1qGkpASzZ89G27ZtMWrUKMydOxd1dXXuuFu2bMH777+PuLg43H///aiursakSZOwdetWdOrUKWLfQBaElC3Ly8tx4YUXYuvWrcjIyHCfBZk2bRp8Ph8SEhLw6KOP4qqrroow4uJEpRwZDofdY+mBQAD79u1zs7va2loUFBTg/fffx969e5Gfn4+nn34aAPC3v/0NWVlZeOedd7B06VIMHToUXbt2RWlpKc466yy0b98eLVq0QEFBAW677TYMHDgQHo8H06dPx4UXXoiUlJSI8smnn36KFStW4JBDDkFWVpZ7iKOmpgZlZWVYv349RowYgcmTJ+Ozzz5D586dcdxxx7mRMa8lNq5sPKXssnLlStTU1KB169ZYs2YNysvLUVdXh+TkZPTo0QN+v9/lpy63aaOtMwRZT7y+uY2O+kVHd+/e7e4r5eXloX///li1apV78m7jxo2YMGGC+/BvQ0MDli1bhsceewytWrXCXXfdhaSkpAgnWVBQgOLiYvTo0cPV++rqajdTZDo40+ASVWFhIebNm4f58+djzJgxGDduHBITE929Ls7CQ6GQe1z6hRdewPfff4/TTjsNZ5xxBj7++GP069cPgwYNcvfRZsyYgWAwiHXr1uHQQw8FAPdQk3w3FbC/qlFZWYlgMIgffvgB8+fPR0lJCW666Sa0a9cuIrDg7IX5rQ8W/K+gyc5FmMXGnTehtDID5qd5hWHCrJSUFFx//fU499xz4fP50LZtWwDAWWedhbFjx8Lv97s1a92/7kvG6t69O1555RUAcI805+Tk4O9//ztSUlLg8/nwpz/9Ce+++y5qa2sxZcoUDB48GH6/301rN23ahPr6egwcOBBt2rRx556UlIThw4ejsLAQp512Gg477DDXKWRmZmLixIlISkpCKBTCzTffjAcffBDXXHMNhg8fjrPPPhspKSl4++23MWPGDOTn52PixIkYMWJEROouY5kiNX3iReYvTkXuZSNRV1eHpUuX4tBDD0VMTAzq6+vh9Xrd45Fjx45FVlYWAKCqqgpz5sxBdXU1CgoKcPnll2Pjxo3Ytm0bysvLkZaWhnA4jH/+85/Iy8vDTTfd5EZydXV1qKysjDiWrDeHn3/+eWRmZmLChAnucV/HcbBz507s3LkTd911F3w+H/7yl79g7ty5OO200xpF47os0KJFC3dRx8TEoKGhAYWFhfjss8+Qk5ODzMxMzJs3D8cccwzuuecejBkzBkcddRTatWuH448/Hmlpaairq8P777+Pbt26oX379vB6vXjjjTeQm5uLP/3pT3AcB8XFxREnu3w+H3bt2oV33nkHRx99NPr06eMe4PB4PNi1axd27dqFXr16Yfz48fj0008RDAYxYcIE92SZ9CXRtciMD2eEQiFs3LgRr732GtavX4+qqio8+OCDKC8vR58+fdC6dWukpKQgIyMDgUAAW7duRevWrdGjRw/39B9nAUDkcxNcLtLOJFqplp3Pli1bUFpaih49esDn8+GII47AzJkzsWHDBsTHx2PNmjWuftXV1WHjxo14/fXXsXfvXje4kLF5b+ree+/FE088gVatWuGTTz7Bxo0b0a5dOwwZMgRdu3Z1j/LX1tYiKyvLLW1K1v7iiy9i9+7d6NevH5566ikkJCQgEAhg3bp1uPzyy5GZmel+P1I4vP/4+dy5c/HRRx+5L+FNTk7GmWeeiX379rm89ng8KCwsxOeff45vv/0WLVu2RFlZGd577z33reWnnHIKevXqhUAggJqaGhQUFGDu3LlISEhwy6Ks0+xU2LEIT3j/iW3A7xlNdi4yaamHR1PCg9ULOSoXeDweJCYmIjc3N+I5kVAohKSkJKPT0vVTHktH8Vwmknqp1+tFXl4e/vjHPzaqmzrO/mOm+fn56Nq1q2v0a2pq4PHsf77l/PPPR0xMTITQJeKW6NPn86Fr16745z//6ZZAvF4vnnrqKVRVVSE3Nxdt2rRxnbaufTPP5X/TZqA+ncUPZMo94XAYbdq0wcUXXxyh0AAwYsQInHrqqe7R47KyMnfzcfLkyUhJSUFWVhYKCwvx6aefYty4cfj+++8RHx+PSy+9FKmpqQiFQtizZw+6du2K7Oxst2zFhwvC4f3PZXz11Ve49NJLARx4YzAAzJs3D926dXP3tRITE926ti4H8iLzer2Ij49HOBxGYmKi62AzMzMxfvx4eDwePPLII6ioqMCHH36Iu+++G47jYNeuXTjssMMinAHz1XH2f9+QPFQqezybN2/G9u3bMWLECMTFxWHmzJk48cQTMW7cONTX17vHl8PhMDZs2IDi4mJceeWV+Oijj1BSUoJLL70UiYmJUQ2J/OiN/jZt2iA3Nxdff/01LrvsMhx22GFITU1FXFwcYmJiUFFRgU8//RQLFixAUlKSG1RddNFF6NChgxs0sf7wQ4GcVbBsROdEj0QOcn91dTW+/PJLJCQkYPDgwQD2Vy6GDBmC7777Dv369XMzZjlZ+thjj6GgoAAdOnTAJZdcAr/fj6qqKgD7T1kGg0EUFhbi3HPPRatWrVBUVISvvvoKkydPRmJiIp577jk3iHvnnXewdu1a9OvXD5MnT3YDsaqqKqxduxZXXnklhg4dimXLlmHWrFlISkrCpk2bMHjwYAwfPhyrVq3CZ5995vLy9ddfRygUQkpKCnJzcxEOh9GrVy98/PHHKC4uRk5ODrxeLxISEtCrVy+MHTsWy5Ytw8yZM9G/f3+cc845qKiowFdffeW+xLehoQHHHXccxo8f7x4uatmyZaNHCrTNlKCA91c56Py9o8nOReqLvCiAyHd86VSb66WmGi7/1vsEuvYobfX+grSVcaTUIN5d+tHlJQCNsgUdHfNc+TkMQbS6NfMgLi7OfagMgFsy4XqtaeNa+mDaJNKTY6emzFHoECcTDAaxfPly7Nq1y3WuwuO0tDRceuml7p6Y7Jl169YNZ5xxBnr27AmPx4O8vDxcddVV8Hq9uP/++7Fo0SLcfvvtiI+PR0FBAfbu3YuXXnoJ27dvd58hGjhwIFq3bo3OnTu7pYjq6moUFRUhLS3NpS8cDqOgoADvvfeeO8a3336LjRs34vDDD8eiRYtQXV0Nv9+Pbt26ISMjo9FegixAWaz19fWuLIPBILZu3YqhQ4di7NixaNu2LdavX4977rkHw4cPx5AhQ5CSkoJAIID4+Hi0aNECfr8flZWVKCoqQnp6uktrQ0MDnn32WbRr1w4jR450n8Xi4/Ei91AohA4dOuDss8/G/PnzUVFRgQceeMAt/+jyk9wj4PXhOPtPqbVu3Rrx8fE4+uijkZmZCcdx3MMkn3/+OTZt2oQbb7wRLVu2RDAYxMyZM3Httdeiffv2OO644zB69GjXadTV1aGoqMjdd0xOTkYgEMCCBQvw+eef46KLLkJeXl4jenh+EoysWLECeXl5SE9PdwOw4cOH44033sC2bdswadIkJCUlYe/evZg1axa2bNmCUaNG4eyzz0Zubi5qa2vx/fffo6SkBOPGjUNRURFWrVqFyZMnIyYmBtu3b4fP53PfSXjNNddgwYIFeO+999CxY0dMmDABL7/8Ms4991zXOW3YsAFHHHEEDj30UIRCIXTs2BHff/89Jk+ejPvuuw/ffPMNNmzYgBUrVuCwww7D4MGD8dxzz6G0tBTx8fGor6/H8uXL0bFjR3z77bfYtGkTRo4c6fIvKSkJhYWFSE1NxfLly9GjRw9ccskliIuLc7+hd926dejUqRMmTpyIjh07oqqqCps2bcIJJ5zg7smITRF9ZZvD65ltw/9KaewXfZ8LRyxiILWB1g4FaFyvjdZ3tEhdM5h/84Yxn+6RyI8NuG7PzkiyDV3i0w7O5EAEnLGJsnBtWn7zqyr0PhIvYolgGxoa8MEHH+CDDz7A3/72N+Tm5kYcrhDo2q1c69SpE4466ihUV1e7jkQMJjs+r9eLtLQ0PPfccxGyDofDGDduHBYvXoxPPvkERx11FHr27Ina2lrcd999WLBgAdq0aYPTTz8dfr8fCQkJWLJkCTZv3ozzzjsPw4cPBwDExsaibdu2rmEU3r/zzjto164dunfvjueffx4ffPABhgwZgo4dO2LVqlXYtWuX+0aEnj17unseMg+RT6tWreDxeNyXqcoXcT344IPuw65erxf5+fm48cYbMW/ePPz444/Iz89HOBzG0KFDXWcivOfnlAKBAKqrq3HkkUfC7/e7D/vW1NS4xlbujYmJQdeuXbFv3z5MnToVDz/8sOtYWF8d58BrjnQAxLpfU1ODTz75BF27dnVflCifzZ07FzNmzMDDDz+M7OxsN6tbv349cnNzMX78eDzxxBNIT0/H4MGDsWvXLnz11VdYv3494uLisGnTJpx++umYO3cuvv76a1RVVeGrr77CpEmTUFZW1uibZMWZB4NBLFu2DDU1NTjyyCPdfQyfz4chQ4bg2Wefxd69e/GHP/wBTz75JDZv3oylS5di/PjxuPTSS913cjU0NGDFihVo27Yt6uvr8cgjjyAvL889tSeviBKdTUtLw65du7Bp0yZMmjQJa9asQUJCgrunt3nzZrzxxhu4+OKLkZycjMrKSmzYsAEnnXQSBgwYgKOOOgrvvPMOhg0bhgsuuAB9+vRBXFwc+vbtiyVLlmDAgAHo06cPZs2ahX379mHJkiW48cYb3f09kaEcGBBH8uSTTyIQCCAjIwPJycnIz89HYmIi+vfvDwDYu3cv9u3bh+TkZPj9ftTW1kZUauS0pzzzJmtQ68f/ucxFohV9QiLapiFv5usFxSUN7VSEqdJOG2/50WfzZXwgcgMMOHCkkN/WqktnpuORuuRnKlfxKyGYDzJHMXAcWXOJgctGuqQo4yxcuBBPPvkkrrvuOuTl5bkyYOcpRoqdlRiv9PR0jB8/3jXQnNXp9ywxTWIo5cWYXbt2xZQpU9znfBzHweGHH45hw4Zh5MiRblYh85G9HZF1bGwszjvvvIgSzWeffYYlS5bgjjvuQG1tLVasWIG//vWvGDRokPuQK++t6eBC6PV49r/2prKyElu2bHFf8eM4TsQGt8ilbdu2OPvss90+Kyoq0Lp16whH6/f7EQgEABx4oDUUCmH79u3o1asXvF4vevXqhenTp+OUU05Bq1atUFVVhYSEBOTm5gIAli9fji5duqBNmzZuqSoQCLhfFFdXV4cOHTpg4MCBSEpKahR0yByqqqqwbt06/OlPf2p03PXLL79EampqxN7gyy+/7B5IyM7ORmxsLH766SccfvjhmDdvHl555RX85S9/wRFHHIGpU6fi6aefxu7du3HBBRe434766aef4rXXXkPbtm1dA1leXo74+HgMGDAAHTt2dEtIkuVKZC+v5Rk+fDiys7ORlJSEU089FcuXL494YWpRURGWLFkCn8+H2bNn4/PPP0dqaqobqABAy5Yt0aVLl4gDRYMHD8Y777yDxx9/HFVVVfjzn/+MuLg4fP/995g6dSrOOecc9OzZE/X19fjwww/R0NCAUaNGISYmBpMnT8aECROQlpbmfuWH4+x/ju2II45AQkICsrKyUFFRgWXLluGiiy5Cjx49Io6by2nP5ORkTJ48GZ9++inWr1+PoUOHolu3bmjVqhUSEhIiDum0bNkSXbt2dQ+ZpKenY+fOna6+dOzY0d030oEnB6u6hPZ7RZOdCy9w4IABYkMPND4iLEZel5NMbaOVukzGW8DOTRtmzoA4EmBnxLSz0eUNVb3YdSnM5GABRGyw83V2ftKvjCXPsYgyVVZWYsaMGTjkkEMwatQo92FKTbuMI/SKgRdjJa/Ql41EdvzaqerISAx0ixYtMHz4cNcwOI6DM888s5HMZLM4ISEhol+fz4cRI0a4MnEcB4MHD0b//v3djdL77rvPvY8XlJalfshQjnj36NED+fn5jUoJwmfe3OYgKTU11W0n8uGHTWX8Y489FmvWrMHIkSMRGxuLM888Ex9//DFmzJiBUCiEnJwcnHXWWS4f+/Tpgw8//BD33nsvQqEQdu7ciaSkJJSXl2PUqFEYMmQIcnJyIr6qgvVF+Lljxw5kZGSga9eujYKwrKwslJeXR+hqdXU1QqEQ9u3bh08++QQNDQ3o1q0b6uvr8f333yMrKwuDBw9GUlISUlNTUVRUhPPPPx9du3bFW2+9hW+++Qa1tbU466yzEAqF8OGHH7oZSv/+/dGmTRt4PB6MGTMG3bp1cx+wFmRkZOCGG25AVlYW2rVrh4suugilpaVISUnBli1bkJiYiIULF2L37t0YPXo0jjjiCGRmZmLPnj0YN24c0tLSXHkMGDAAXbp0cYMjj8eDvn37YvLkyVi4cCE6deqEbt26uWWmkSNHuic+w+Ew2rVrh/Hjx6N9+/ZukJCTk+PyWZ6tSkhIQH5+vqtzV155JYqKipCZmRnx3JTP50Nqaqr7KqzU1FScccYZrry0XRSZZGdn45ZbbsGbb76JN954AyNGjEBWVha6devmvqOM1xGvAdGn/6U9F4/TRBdYWVkZYRBNxlE7FR0Vcx2cFz3Q+Kw+fy4Ljp/7iGb8TaUzifT5tSKaZiDyoIEYYS73ifKyMebMQe878fzEYcg4zEO5X/rlJ613796NG264AaeeeiomTJgQobRcBjM5G1PJTXgRCoUijgtzVsiyEL6xUeZXzfA4fNBD6OIMi+lg+XKGJ/zhDI/LrvwgncyB6d+2bRvy8vIiyn1a5sxvlhFnjqFQCEuWLEHHjh3dp7Dl+Yza2lrXGUlfOjtlmX/11VdYsWKFe/Jx+PDhyM/Pj9g7M70zjun+6KOP8PTTT+O2227DoEGDIur0Tz31FD777DPMnDnTzWo2btyI66+/Hnv27IHH48GECRNw9tlnIyEhAZdeeilGjhyJc889F6FQyP2aCpnn008/jTlz5uBPf/oTjjzySMTFxUWUmfmryDnTYn4ID3Q57euvv8bUqVPh9XoxevRonHDCCejYsaPbl5SaRPc4WtdBIh/L5/XU0NDglkGlnciHs32thzo45Syc7wH2l7hqa2vdDFkHK6zrvKbEBtXV1UXoji6Zc3mf6RP9Gzt2LCorK/FboSluo8nOpby83GUC14a53OB2alisPAx7Zi00+ZujS73gdElLGzGPx+OeNOKH09iY6MhWjKOmQRaVGAB2UHqOJrrZeLCiiEGVd4ABBxaXjCffzvf555+joaEBEyZMcGnjvuvr69158CahgI838/uPuNbL7fVeDvOFIykGZ5ksJ27LJ6mkDTsUHfmxLDRtwkP9Xi/eW2PHreXKxkpo5zG5T44YhT7WS3kNjdAnNAnv5CQWG0A2wPp4uf4c2P8MxYYNG9CyZUvk5ua6c2poaMDGjRtRX1+PPn36RLynbd++fSgpKUFsbCzS0tLcE4t79+5FXFyc+9UXEmTInCoqKrB3715kZ2e7L8BkuXKApXnFPOAAw3EcN5OQl6Smpqa676hj/eLsW2St1z7rGuu0rk4IbfpzTbMO9ARaP+R/CRz44UzOUnhchpY5Ox6esylbl/biXOSE3W+BZncuHE2YmMbRKQtEGx42MBwVCPgFiCaDJddkEcu4Omrk8bg/jk413eykJHPhKJpLEibnyZE7KwQfq5VjvzIe08d0s0FynP2lLaZDFFQyQa4H60XEMgIOvCxS9ml4QegIkRcJl++4fz7kwVErG3CWOdNjGj+a7HWJgPdkeCz5X/rkfrTKc3vO3sSB6Xs1rfxbGxQxnmwIRWa6ji598v6OzJMdLq8tkaEET+zceE1oZ8Xy1NeAyMoAy0L6Ex3W64J1jeUrvODs2pQBCx+5dGsy+hwgcIBicjLadrAx1/picmRan2R+Wo/Y1on8tI1gHWE7yHZR9jsFPEfHcVBdXY1TTjnld+9cftGei8nzR4sEdFQhym2KPEyEsuBZkJI58EscpQ+Oevi3tJFFyGm9ZhSXwoROdj5seLgNZyWivPwthDxnplM/yc5ZhUSIYkDlCDEvao6u9cNwbOxZQWWeMrZ2+LKwTbIy8UwbFDE+JsfLstHGn3nNBpuh52yKFrWhNzkXbVjEUDOf2PDyXLXeC+9MeqGDDaZZ5MB08/1suPlz1hN2RmwEdYCiHavmGTsOnrueA/NKrzO9VqPxgukDEJEF6YCP9YLHYFlpZ6LtFNPC/Oe+tX7p+4U205y0bumvY9DjsRx4TgKtm/ozdjy/Z/yio8gscJ0qa+bpKEGucVtTKUzAzoiZzRGyjnD04pZ+TH2wYspnrNh87lw7FF3yYofBc9QRklYsNgDCH/0mAq7ZagNvusbzAxDRt9zD95rkpA2e/OZMih0Wz4ezI+20OetjfWGZsePUJT42XibDz7ziyNGkV/pv3ssxGWL9W2dQHHVqcHuO3LnMxv2z8Zb/tYPUMvt/7L15nFTV0T7+9PTMdPfswywMMAMMIMMAssimAsoiIq6AIuCKEveoSYx5X79J1CQmJmr2N/F1STRxiYIgSxRZRJFFEERkh2GHYZt9n+nt/v7gV5fq6nOHwXQiyVvP5zOfnr7LOXXqVNVTZ7m3Ted4v3EdmHyEbJjbo5wR4D7fWtB0Cs6yz51kksRCcnESam3aU8Yg0+iQxxeTjk1lk2xO95H/8v51mj7k/SNnRJz0RMf/+te/2q+SOpfRZnIBIjMXSQbcSTkpcIM3ZQ9ApJPLuuh/qWAqp7Vz0jBk/ZygeBuoLBmYuVFwhwROB3HaoksGQ/PMpmAuDUiWz+fPgcjfv+AjFR5oePtJdj6Hz+vkpMkdhgcauo+THl1LGZrUMZcPgJGAOAnxMnkw4QkNv072K7+fvzWB9w+fjpI2JW3VVD4/Lu/jtsrtimfq3MboHqcAx184Km1Ckjsdk6QrR0GmJMKJdGV/yGtkf9Kn7FseoKXNSRnIV+TbP/h1nGScgj+vj8slidCUYMi+k+0n2+SfvCzpx9wWW9OzHC1x0pFtjIuLQ0NDg6ONnks4663IQHSAIEPmBm4yLDpn2g7a1sxBOpzL5YrIqOU9MuvnZctsQa6z8CDAd3IRqB18pxOVK2XlhsINzLQNmBu3/C4DEi+TOw83ft4uqW/eF1wPZNx0D02j8T4zESTJxeszBVDeP9IeuD5MZMD7RZK1JEBT4sG/84TDZD9SV5KUpY3z/uf6NZEpEJ0J04iN60LKZOp/Xh+V25qNULtM56SNEviIVpKqSW+yH+Q9vM1y6pn/z79L4uaEwG2X3yOns7h/ctlNa5a8n2S9Jn/i9/DvvC7yJ5NNmuRy0u25jrN6iFI6CHD69efk3KZMlu7nC5Sys3iA4cGYT1cQeBmm5zY4afDMgcsuSUd2PsnE65SkRNfyYAycXheSjszb4JTdmxybO05rwZMHcC6T0yiT65sIlAcQ7thymzOXSyYDUqe8TXx3nNQHkbdpVCGDjKzHiUS4niV5cdlNbTMFX6kT6jupU1NgN43EeMJg0rskTZ4ASDiVw/2JT3U56YvrUtYrExeTfmRiSOXw6T/pQ5LkTcTFr6drufySDPl6r9yRx9vEZW+tH+TIhCeXHKQj2TZePycYrkOpE267Jr2cy2gzufA1CB5Q5RPqPFuQc7QEqSD5kj4e8PjQX9bDg6KJ9TlkZkOg3Vn8AS2ZDckALp2EZzx0jF7caJpaI8i5Zekc3AFlG2V7JSHxNpNjmxxJZpI0lKdAyEc/1Ea+y0febyJF7pQ8K5d9ZbpXgjuZKeDzsjghy2DIR11yWkLquLVgJPtUfncK1qbg01r/8UDKgybXr5wtMPlLayTNA55ptOFE5DzwmvpCBn/ZXn4v7zsnGbhtcjuhYzzZlETG5ZHtkeVx8L7hSTLpjbdB2iHVJUmRf6f6W7MpU/nnMs5q5EKfJmflDM+VbdphwZ2Md7ycAuEZIQUkPjKh49wo5CjC9NwHgcrhaxv8VSHc0Gh3GhEqD9hkzKaRiMx4nAhCkhh9SiKQOuWL1rJO3k6qh/enNFK56M4XxU1955S9StlNbZJBUtoa140cYfKNBNz2ZLbPs3a5viZtxUTWpk+nfuP6p+ulvrl8ra1VcR3wbcVA5EK21KfsU6lHU//z/qTj3AYkcckRPN3D7Z7LayJPaZtUj9yAIW2DP7MmZeSQNmwawfPpLKeALclP6o7q4RuEpE2aiEaSKP/jbTKRrpyFOJdxVmsuvNP4OocpOHJH4wGeD/NNQz/eARS0TYGLPk1ER+DzmrzjpJxxcZEPffFOlAt41B65hVdmfDx74kGOkwLJII3XZJhym7EkcDlnTddJvfDARKTKdW9Zlv1AIF3PAxD9L7dPy77hAZ0HH9l/8il5Gez49dLWJNmZpopkOSbb4f/LMmRwMM2xmz5NxGKCJDZT0sb9gt/DfRKI3IkmkwCyUbJLOZXH+03ajAz4Tv3Dp9/oWiCSYKRdc6KSNiPrkEGb60aSn0wyuA3KOMTvl31hmk2QU1VnWlfjU/tyJCOn4J3ISPrgvwO+0luRgehgJRmWH+dZPh3jf7zTZUbBH5KTZMDl4IEfQIQjOWUd3CmkU0oDonOmHVBcR3LoS//zkRrJ5+TE8tPkGJKAuOHJjJ3rjjsc6ZHKC4VC9siNZ6wyw5LBhreBt5fOUV2WdfoNwAAidkXJ9zHJACtB5ZuCM1+LM62f8TJMtsEDF4cpgJiCJk+upM/IYMX7FIiea+f3OoHXw7N0k51IEuc6lD4ticapLJlhS91wnci2SPuVvij9TMYQU2LG/5exhpORHLG1Vq70YU4cpjqoflPiw++XSYoc3XCSk7Z3ruOspsUkk5MTyzlHufBMn9zYAUTsv+dZAHcUCqym7ElmkXzbKS0c0ytbqGwiHPmQE8loWVbEGpDL5Yp4YJOuk7JzB+WZJDc+rj9JKFwG01SCzObkEFkGWlmfzAh5IOfXyx0z0tl4oiADK5eP30+QmTmNAE075rhzSTvk/5uyen5eBk4OGfxaC8Cyr5yCDydkIk0ut+n5FdKXaZRoInKTTPJ63l88QTAttvNEjso0JZOmPpF6Nd3DSUJeb+oX6dc8rvB7ZJyQdcnkkOuGpoD5dmEuO0/mCPL1RSZ9m5Jt03Qzr0fGSmlXpuTq3wFnNXKxrNPTGHQMiM7IpOHStTwQOI0M6E/uZqE/Xg4nJOmIcupAGgM3Hh7sAESQlIk0SA4eaOWWXj51RvVwyJEdHZNBS7Zf9ocpQPKdUdw45TSJHJHIUQrfrMGDoFO2JdfITMTo9MAr7zdOsFz3MiuVbZOBtLVMWspO53kfS/3LREC2jdsbl0uOdKQtEQmZjpvsh3TDX3bJ+1z2D59yoZ9B4Lv2OAnztvP/ZfYsdcEzbNmf3A5NZEJtknXLvjDd7zSDwP93Ihg6L2OGSR6eKPC2U/uknfC6uU/I9TI+ipH1Ofm2kw7PNZz161+A00qjHWF0jitLOgXvQCcH4lMB3CmdGJ1PIfAOp5GHfINuXFxchBPzQEyyU/38d71lJsl1wsum6/hajyl7p+88a5HThvQpiYWTAHcY3g7+6hZp+LJ8gimI0+tyeOBwciJJTDxjl0GIPp2ukVMWTlMBsk08iHKb4Fk7b5/MTk0jA5Ou5JSGSa/cfk2Bk7cPOD2KM52XAYfLS22j+mSwlf4VCATs57KcRhlOozWucxPhSxtwkl8GSE6Kcg1GyiYTUalv6mfpj/KRBhMpyCRBgq/Nktym9kk55ehV6lEed5qWlPo813HWu8VoiohIhbOzyblN2QYdM82nSqMHzLsspBGbypFZiWmIyaf16F45jyqzL5JFDsflQ2a8fi4bPy+DjCRLHjwkKVO7ZMCRZCB1acraeL2msriu+Y+I8XP8GrleIJMFmf1KWeg4txGnoMnrkU+3S+floxo5MuC2IftF1s9fseMUSOm7ae2Ej3p5EOVTOrwc3m4pHyVNRB6cRLnu5GtduCxcDupbrns+ZUfX8xhg6jveZqlr3jdyMwpdL5NG3k/cP+i4tF/T+ifXGb9PvsCVy86TWN6n/G3Scns41zvvf1PSwnXMPwl8luTfCW0ml9GjR0d8NzG7E6P27dsXt956a1TGJQMmNybZ0ZTlc4dITEzEwIED7TJpDYiXZ1pI45kr/UIlfedtMwVbKpsbmzQq/p1fR2XyNvDjcipQjj7kqMmUyZkCtzRkmT3K4Csdj/cXbwNfMHeqSwZyOQrlx0w6akuWJhMImSxIXch+dUpGZGYvSZ2XbSIrAs92iVB4n5Ld8QzbtOBs0osMnK3pk3Qjdyry8mT7OKnwOvmmGrqHb7KRW5OlTkzkZloPMvWZ7AtTksHrlORFn1xG0/oxHae+Melb6ln+z+WWuuBELdvN3whyNr5wLqHN5LJz586vXMnOnTvxzjvvfOX7nRAfH48rr7wy6glZaVwySyLIjICTRXJyMu655x54vd6IQGxyOjIeuUmAD8/5tXFxcUhJSbFllRkmcPohVJKH1yezJJnhyVGCDOg0ypSbDbi+pGw8GJj0bArKMuOU98uMVxKQvFZeJwmKj2ZlYsHlMWXDpqka2QZ5z5nayO2Nk7TUpSQSU/ZPyRUnTvpfBkWTfuW98ucc+PX8DRN8mzvXLb9eriPw4Ex18fUKE0GYpquo3dI/pW5NJMhllvXx5IlPTVMd/Lk3PsVsmmXgfcv7TvoB9TGX2fSEvvwpC1O9/y44qxdXnmsIBoNYsGDBP638uXPnGkdoHNxB+DHAeVdNZmYmbr311qjj3CH4tAkPPjJjk9MHY8aMQWZmpn2eBzNpyKZpQiAyEMlnYEyBgf88gBP4/fy7qT2yvU4Zm4nsTO2U5cv7TSMZU4Dnx2UmTeAjVRm0nEb7PBhy3ZgIyUTovC4e2Pm98pcu5YyBXHSXSY9sP19X5GXKcvlah5TN9E5ALg9958/J8Xrl8yNkf/wJej76oDrkyE0+YyJtjxOX1IXsX5NvmWYZTA/R8nv4/3zThtP647mINv9Y2JmCrOLcAP3E75ngRIrSETjuvPNOZGRk2E5IjkvTIaY3YptGQkD0usp5550XMQKVBG0KQlJ2fo8pgzYFZklABNPoSJKOXNuQo1m+g4v0ZeoH3k4gck1RBhv6k5mxkw7ojz/oR33Fdzpy/coRgdQxlcGnkmQ7+DW8/0h2OQ1JMnH98brl2ls4fHpdiBOr3LDD28V1xe9x0rn8NNmPbDu1T/7yqNSrU7+ZdAZErmH+7ne/w6JFi/B1oi208W89clFE49ChQ/+0sh977LF/SrlxcXEYM2aM/ZvyEk4ZvwmSzCZMmIA+ffo4liWv58fkaMFp9EFwGmFIgmxtmoOTFc/85cjgTMkef17MVD4/5/QaHklisj38GgInIDmS5WXJzJ1IjoI8EQXXh0wC5PV8txiVaQLdYyIT02iElyU38dB9TjbEdcJ1JtvF75GjYnltG8cDXzvaPHJRKBQKhaKt+PeZwFMoFArFvw2UXBQKhUIRcyi5KBQKhSLmUHJRKBQKRcyh5KJQKBSKmEPJRaFQKBQxh5KLQqFQKGIOJReFQqFQxBxKLgqFQqGIOZRcFAqFQhFzKLkoFAqFIuZQclEoFApFzKHkolAoFIqYQ8lFoVAoFDGHkotCoVAoYg4lF4VCoVDEHEouCoVCoYg5lFwUCoVCEXMouSgUCoUi5lByUSgUCkXMoeSiUCgUiphDyUWhUCgUMYeSi0KhUChiDiUXhUKhUMQcSi4KhUKhiDmUXBQKhUIRcyi5KBQKhSLmUHJRKBQKRcyh5KJQKBSKmEPJRaFQKBQxh5KLQqFQKGIOJReFQqFQxBxKLgqFQqGIOZRcFAqFQhFzKLkoFAqFIuZQclEoFApFzKHkolAoFIqYQ8lFoVAoFDGHkotCoVAoYg4lF4VCoVDEHEouCoVCoYg5lFwUCoVCEXMouSgUCoUi5lByUSgUCkXMoeSiUCgUiphDyUWhUCgUMYeSi0KhUChiDiUXhUKhUMQcSi4KhUKhiDmUXBQKhUIRcyi5KBQKhSLmUHJRKBQKRcyh5KJQKBSKmEPJRaFQKBQxh5KLQqFQKGIOJReFQqFQxBxKLgqFQqGIOZRcFAqFQhFzKLkoFAqFIuZQclEoFApFzKHkolAoFIqYQ8lFoVAoFDGHkotCoVAoYg4lF4VCoVDEHEouCoVCoYg5lFwUCoVCEXMouSgUCoUi5lByUSgUCkXMoeSiUCgUiphDyUWhUCgUMYeSi0KhUChiDiUXhUKhUMQcSi4KhUKhiDmUXBQKhUIRcyi5KBQKhSLmUHJRKBQKRcyh5KJQKBSKmEPJRaFQKBQxh5KLQqFQKGIOJReFQqFQxBxKLgqFQqGIOZRcFAqFQhFzKLkoFAqFIuZQclEoFApFzKHkolAoFIqYQ8lFoVAoFDGHkotCoVAoYg4lF4VCoVDEHEouCoVCoYg5lFwUCoVCEXMouSgUCoUi5lByUSgUCkXMoeSiUCgUiphDyUWhUCgUMYeSi0KhUChiDiUXhUKhUMQcSi4KhUKhiDmUXBQKhUIRcyi5KBQKhSLmUHJRKBQKRcyh5KJQKBSKmEPJRaFQKBQxh5KLQqFQKGIOJReFQqFQxBxKLgqFQqGIOZRcFAqFQhFzKLkoFAqFIuZQclEoFApFzKHkolAoFIqYQ8lFoVAoFDGHkotCoVAoYg4lF4VCoVDEHEouCoVCoYg5lFwUCoVCEXMouSgUCoUi5lByUSgUCkXMoeSiUCgUiphDyUURM7hcLjz55JP/Z+r9V6OkpASXX3450tPT4XK5MG/evK9bJIXCEUouijPi1Vdfhcvlcvxbu3btP12G999/P2YE0rVr11bbQ3+vvvpqTOqLFW6//XZs2bIFP/3pT/Haa69h8ODBX7dICoUj4r9uART/Pvjxj3+MwsLCqOM9evT4p9f9/vvv4w9/+IORYJqamhAf33ZT/s1vfoP6+vqIsv/2t7/h17/+NbKzs+3jF1988T8kcyzR1NSETz/9FN///vfxzW9+8+sWR6E4I5RcFG3GhAkTzsls2ev1ntX1EydOjPh+/Phx/O1vf8PEiRPRtWtXx/saGhqQnJz8FST8x1FWVgYAyMjIiFmZX2d7FP/50GkxxT8NBw8exP3334+ioiL4fD5kZWVhypQpOHDgQMR1gUAAP/rRj3DeeefB6/UiKysLI0aMwNKlSwEAM2bMwB/+8AcAiJi2IpjWXEpLSzFz5kx07NgRHo8HhYWFuO++++D3+9sk+4wZM5CSkoK9e/fiyiuvRGpqKm6++WYAwMqVKzFlyhR07twZHo8HBQUF+Pa3v42mpiZjGaWlpZg4cSJSUlKQk5OD7373uwiFQhHXvvXWWxg0aBBSU1ORlpaG888/H7/97W8BAE8++SS6dOkCAHj00UfhcrkiSPCLL77AhAkTkJaWhpSUFIwdOzZqqpKmNlesWIH7778fubm5yM/PBwCMGjUKffv2xebNm3HppZciKSkJPXr0wDvvvAMAWLFiBYYNGwafz4eioiIsW7asTTpU/N+GjlwUbUZNTQ3Ky8sjjrlcLmRlZRmvX79+PdasWYNp06YhPz8fBw4cwPPPP49Ro0Zh+/btSEpKAnAqeD799NP4xje+gaFDh6K2thYbNmzAxo0bMW7cONxzzz04evQoli5ditdee+2Mch49ehRDhw5FdXU17r77bvTq1QulpaV455130NjYiMTExDa1NxgMYvz48RgxYgSee+45W97Zs2ejsbER9913H7KysvDZZ5/h97//PY4cOYLZs2dHlBEKhTB+/HgMGzYMzz33HJYtW4Zf/vKX6N69O+677z4AwNKlSzF9+nSMHTsWv/jFLwAAO3bswOrVq/Hwww9j8uTJyMjIwLe//W1Mnz4dV155JVJSUgAA27Ztw8iRI5GWlobvfe97SEhIwAsvvIBRo0bZpMBx//33IycnB48//jgaGhrs41VVVbj66qsxbdo0TJkyBc8//zymTZuGN954A9/61rdw77334qabbsKzzz6LG264AYcPH0Zqamqb9Kj4PwpLoTgDXnnlFQuA8c/j8djXAbCeeOIJ+3tjY2NUWZ9++qkFwPrrX/9qH+vfv7911VVXtSrDAw88YDmZq6z3tttus+Li4qz169dHXRsOh6OOPfvssxYAa//+/fax22+/3QJg/fd//3fU9aZ2Pf3005bL5bIOHjwYVcaPf/zjiGsHDhxoDRo0yP7+8MMPW2lpaVYwGDS2z7Isa//+/RYA69lnn404PnHiRCsxMdHau3evfezo0aNWamqqdckll9jHqA9HjBgRVc+ll15qAbDefPNN+9jOnTstAFZcXJy1du1a+/jixYstANYrr7ziKKtCYVmWpdNiijbjD3/4A5YuXRrxt2jRIsfrfT6f/X8gEEBFRQV69OiBjIwMbNy40T6XkZGBbdu2oaSk5B+WMRwOY968ebjmmmuM60N8Oq0toNEFB29XQ0MDysvLcfHFF8OyLHzxxRdR1997770R30eOHIl9+/bZ3zMyMtDQ0GBPA7YVoVAIS5YswcSJE9GtWzf7eIcOHXDTTTdh1apVqK2tjbjnrrvugtvtjiorJSUF06ZNs78XFRUhIyMDxcXFEaMf+p/Lr1CYoOSiaDOGDh2Kyy67LOJv9OjRjtc3NTXh8ccfR0FBATweD7Kzs5GTk4Pq6mrU1NTY1/34xz9GdXU1evbsifPPPx+PPvooNm/e/JVkLCsrQ21tLfr27fuV7ueIj4+31yU4Dh06hBkzZqBdu3b2Osqll14KABHtAk5tNsjJyYk4lpmZiaqqKvv7/fffj549e2LChAnIz8/HnXfeiQ8++OCM8pWVlaGxsRFFRUVR54qLixEOh3H48OGI46bdfgCQn58fRbzp6ekoKCiIOgYgQn6FwgQlF8U/DQ8++CB++tOf4sYbb8SsWbOwZMkSLF26FFlZWQiHw/Z1l1xyCfbu3Ys///nP6Nu3L15++WVccMEFePnll79G6QGPx4O4uEgXCYVCGDduHN577z3813/9F+bNm4elS5faz8TwdgEwjhIkcnNzsWnTJixYsADXXnstPvroI0yYMAG33357zNpC4KMuDic5nY5blhUzmRT/mdAFfcU/De+88w5uv/12/PKXv7SPNTc3o7q6Ouradu3a4Y477sAdd9yB+vp6XHLJJXjyySfxjW98A0Dbp7NycnKQlpaGrVu3xqQNElu2bMHu3bvxl7/8Bbfddpt9/GyntCQSExNxzTXX4JprrkE4HMb999+PF154AT/84Q8dnyPKyclBUlISdu3aFXVu586diIuLixp5KBT/KujIRfFPg9vtjspwf//730dtw62oqIj4npKSgh49eqClpcU+Rs9jmIiJIy4uDhMnTsTChQuxYcOGqPP/aMZNmTwvx7Ise9vwV4Fsf1xcHPr16wcAETowyXL55Zdj/vz5Edu7T5w4gTfffBMjRoxAWlraV5ZLofhHoCMXRZuxaNEi7Ny5M+r4xRdfHLGgTLj66qvx2muvIT09Hb1798ann36KZcuWRW1d7t27N0aNGoVBgwahXbt22LBhA955552IJ9EHDRoEAHjooYcwfvx4uN3uiAVojp/97GdYsmQJLr30Utx9990oLi7GsWPHMHv2bKxateofehCxV69e6N69O7773e+itLQUaWlpmDNnzj+0BvGNb3wDlZWVGDNmDPLz83Hw4EH8/ve/x4ABA1BcXNzqvU899RSWLl2KESNG4P7770d8fDxeeOEFtLS04JlnnvnKMikU/yiUXBRtxuOPP248/sorrxjJ5be//S3cbjfeeOMNNDc3Y/jw4Vi2bBnGjx8fcd1DDz2EBQsWYMmSJWhpaUGXLl3w1FNP4dFHH7WvmTx5Mh588EG89dZbeP3112FZliO5dOrUCevWrcMPf/hDvPHGG6itrUWnTp0wYcIE+1mVr4qEhAQsXLgQDz30EJ5++ml4vV5MmjQJ3/zmN9G/f/+vVOYtt9yCF198EX/84x9RXV2NvLw8TJ06FU8++WTUmo9Enz59sHLlSjz22GN4+umnEQ6HMWzYMLz++utRz7goFP9KuCxdmVMoFApFjKFrLgqFQqGIOZRcFAqFQhFzKLkoFAqFIuZQclEoFApFzKHkolAoFIqYQ8lFoVAoFDGHkotCoVAoYo42P0T5xhtvIDExESkpKcjMzERmZiZSU1ORkJCAYDCIxsZG1NfXo6mpCcFg8FTh8fHweDxITExEYmIi4uPjER8fj7i4OLhcLvsVGi6XC/Hx8UhISEBCQkLUKzbcbjcSExPP+nXpEpZloaWlBdXV1aioqEB5eTmqq6vR0NCAQCAAl8sFr9eLlJQUpKWlIS0tDcnJyfB4PHC73baMHo/H+FJDy7JgWZbdtubmZpSXl+PkyZMoLy9HVVUV6uvrEQwGYVkW3G43vF4vkpOTkZ6ejszMTOTk5CAnJwc+n88ui+uKEA6H0dTUhIaGBjQ1Ndl/gUAA4XAY4XAYLpcLHo8HKSkpyMrKsl8FwmUk/XN90/+VlZUoLy9HXV0d/H4/QqGQfW84HIbf70dTUxMaGxvR3NyMUCiEhIQEpKamolOnTujevTtSU1Pt18C4XK6Ivo2Li4vQGZeBn+Mykm3xV8vQZzgcRllZGY4fP27rOhAIADhliykpKUhJSbF/7TE1NRVJSUlwu922nk0ycbujNpOeQ6EQWlpa7D6lMhITE5GZmYn4+PiI+6lsrhNqE9UVDofR0tJi22VcXBx8Ph88Ho9dVjgcRlxcHNxut123ZVnw+/2ora1FbW0tWlpaEAgE7PIty0IwGLT7IT4+Hm63GwkJCUhMTERSUpKtG14XycX7iNuB6UFPfh449Robskm6PxAI2DGD2kn26vF4Iuq2LMu2P4ofpAeyF6qX6qHvjY2NqKioQE1NDRoaGiLiU1JSEjIzM5GdnY3k5GS7Lrqfy+bz+WydcXmkndAx6nuSNy4uDvHxp0NuOByO8INgMGj3vd/vRyAQgN/vR0tLC0KhEOLj45GcnGz7lOwPqod8jMqnT15vY2Mjmpqa7HoorpGdcdkB2K9sovLbtWsX1ecS+hBlG2BSkYno2qJK6YymwN5WmeQbeAkyQJIz8bq54zsZqZP8PNCYCJaCLhm12+227+OBnBs9OSxdx4MFyRgKhezgyJ1UkjD/o/vi4uJsvUh5SUYZQE0/qUwy0h8nOCqD9O1EkHSOO7+8lgINh2yjTMIo2PE6OIFI2XifysSI12ciDxnUnUDl0jvSTImS1C1PFpzqpHI5yfK+4WVSvQRKcjnZShlMtkD1SpuQoPP8jdKSaFpLnJwIQfYLJ9hwOIyEhIQIf2tNz/wzHA7D7XZH+RxvD7eN1n59lkNf//L/g2cgXxWtOQ7BRCxtvZfAr5OOAUQ6JRmZaQRkCraSWLhBc6OUxsZBTsSDp1MZRGY8CySn5+3j95EzyBdjymDN66GyTH3MX6TJy+N10n08gMsgQaNfkk+SHC9LZr78uyR9Dl43XUdlmF6PHw6HbSLmgVMSCb9e6qq1IEX97HQdbxcv10TyPCBSciJlcdIJ3ceJR+qd10M2wpMkk62b6uHkY5JLkj/VR0HflJBRGU7kyOsw9YtMGrnfm3QtkztO3FLHJrtpC/7jyOWrksSZ7jFlQGdTrswW2lqONC6Tw5nq4sGQOxAfijvdz8t3yvS5PJIwZYDkzkj302iCB1bePrqXB35+PXdWABGjJXJqXh4dl22WgZHrzin48vbKEYcsj7ebBzQZRHh/tObEMmM3ZcG8Tj4NzafunPrUpBuT3qhf+L3SVk2EarIF3ib65MQrgzi/nvTAR39O5En30GiFkyPZo9SLqQ9MyReVReCjSukTvAzebm7rptEUbz+1lfRJCQSfEqfvppjjlCCZEkF+/GzQZnKZMWMG7rnnHvvV5wSPx4OuXbtGzJF+nfhHRx9tLVcar1O90ml5xuA0V+0EUwA0ZWfyfxm0ySj51JKU0ZQlyfK5kZvqkfXR9XQPrdFwAuAZl9MoSgYJLi+NaKScVL7M7uleGZyofl5OKBSKmHuWuuGyy5EXb7ecspBZtlw/cLrWFHAJNCVGfUyyS3KS9ibbzD+d+sEkHweRPiULlBTIaUUZqE1tAk7bCW+PhJO/8tGEvI7WVui49BlOWq0lIFxOup7bP7d3U9tNyUdrwZ4nklxe/iljFV9L4QmeTCTOJEdraPOai1PwzMzMxF133YWnnnoKCQkJbar03w1tVWZbQUHRKXi2VSb+ZzovjYScwu/32/PUMjg7ycAzSu5kpmBtWacXJ+VUh8vlsueGQ6EQPB6PMWuTpM3bI4kgPj4+YrGXw+/32+XweWXeLlkvX4DldQYCgSjyobbyUSGXVRKQDKYUSHjmyREMBm3dtCY7bwMt1icmJtp65zrmmwnkPLupTH6NJDI5LWYqh+yGQyYSpjUCshfeb3Qfv573F5eT25EpgNP1smzpk9wG+Hkqg3yA+xTvb14X/S/txcl2pN44uJzx8fERRCDtTvo36Yx0LGcI6FpeHj/esWNHR7lsmc54xRlQVVWFX/7yl6irq8OvfvUreL3ef7TIcw5OBCCHnNL5TSwvszxT+TzY0zGngMWDHJeLPuVIgZyVG78pS5TDdp6xA5EOKeXhmZd0aMuy7AzRNNKh+kzJjAwafEqEkx7JJaeBSAeynfw8rf+4XC57pxmBy8zr4edNGbEpcJj6h2Tg4H3O2y2DBIF2VtICsim7l7qTdmWq38kGeaLhNG9vShSkDuV0r9QjnzIz+Q3vC1N9Urfc9oPBYARB8JEWbx/vK5KF5KENAlLHXEbef7IvJdGSLK39TDb3SSd/k7qRvsPL4UkgR2t6bA3/8MiF4PP5sHfvXnTo0KFNFf+7gitYDpvlNJPJwbghkRNyA+aOYco4eNncKU0kxp2CpkUkccngYWqvdFa+O4cHCE5Ufr+/1fJoxEGyyWtk8DKBOzUPBiYylO02tZ/aZtIHtc0kLxA5xy6zZN5PnJSpfrkIzXXA+42fd7vd9hZ5riP+3TRyJBm4vpx0YrJfnoFTPZzAuJ5IBr4Litui1A2Vy3Vl0omUyTRK4etRpnv5dfy72+1GIBCISMRMuiFQkCZ75qNCngxJGbl+qBxTcucESRLSPqSO+Hcpj2nU2JoMLpcLnTp1alU+IIYL+pZloampydiJZ7rvbK7/OmHKeLlD8XOmoOxUlinLMc2pyvulYZh0yTMjSWQ8g+LlOjkwv15mO1wnPFM/U7ncufgCvVPg4Prl7eM6kXPPrW2X5ffQ9BoAx0yUZ5icTJ10SddzYnfShZSJ2wARZlzcqWdofD6fY7v4qE2WyfuR121KXkx65+2XhEr/05ZxOb0iM2zTCEFm47x8PiLiZMYJmtpPZUgdSMjz/JkhaYNOfcVtxzRSaS3GcX3yMp3aIPVpmnUwJTeSRE1JprxPnjtbxIxcXC5X1GK/BO+s1gLP2cDkFGe6RuKr1m1aEHWqT2ZR8loTwcgyTYGcslA5ipJ1c2flaxZ0vaxXymua7pHf6Tq+jdTUBiISckouF3dimf3Jsvg9Urem0aCTHfCdaqRPWpfi7eS7klrbXmvKBi0r8lkap6BH7eRrSFxvfMRn6g8ZtGWAJltxGqEBkdMxPIPnma4c3cjgRYGa38dHYiSn3AHI/+e6kcRiSipIV3I0J2GyKy6fDMh8cwYvV5IibU7hoxdTe2jKktYlTSRkGrXJPuJ2K+XifWGKK04xVxIOl02Ovs+EmJHLiBEjkJSU1GpwbA1OATnWkHPkVPdXretMHSSdl5xbBj9pHCYykTAFLxMBmYhcOrIpS+XXA9EOLkHlyB0ovDzZdnktD5yyflO7ebnyHjlKMJUj7+PXm0iak5qsR67nmNogg4kTTLLLrN0UQGnUQDAlBbJ9TsFCEqb8c7J9aeNcFpkUSBKR7ZHEKuvi7ZZTRE52LYM26VZufOAk5tRfcts7T/p4XVSPfPDVlDyZ+lrOZNBxTtAmf+d6kn3WGvma/OpsY2RMyCU/Px9PPfUUUlJSIo47CX8mopHXfVXCInCFy90xZ4PWsqEzycWNhE+98GyYshGetXAHNGVvfNeUqV65u4sbKg9cMqiaMqXWDFM6AZef38fXSMLhcMTCM8/WZaZsqot2EcmpFZ6dtyY33zEjyU7qR44g6H4qk+8kI8hynBZKTfqkQERl8m3XpCuZTADRyQv3ITnPLwMhySGzd24fsj9lAKf6qW95hs2vkffzdjsFdCcylFNLTnVJ0PV8azQnKVPZ/F7SFenQRC58nYvrXxIcL5P3EZ9GNIGTISVniYmJEf3AiULGCpMNctsjf2wtqXTCP0Qu3bt3x/jx4/HQQw+hZ8+eEefOJvCf6R6nLInfI42+LfWeibxiBZ5lmBzLNIKSGavJ2ch45XQSN14nR3Saq3WSn9fplMUBiHidhmwX37pLsvDzPKszLWJzvXC9coeR8/y07dnpflNZ8jqSVQYF6hvpxLIOahvtPpPrNPw6UyLESQWA/V6zhIQEm5w5qZpshYNPicqkRAYT0wI+1y9vC5+e5cQn7yPwd+zxAEhB3pTgmJIFrv8z2SeH9Bn5xgSuA16uTGT48yGcHOWoWE6lEjh5SIKU+uDEJeX3+/2or69Hu3btoqbsaUQryUX2jynZoE+6d8+ePejSpcsZ9fuVyCUpKQl33nkn7r//fhQVFbU6f0vHWwvgbTEEWYZlnXohndfrdRzWm4IFdT69yK5bt25GOUzytian05oEBX+nNQiao+X3SpIxDYmpTklWctpP7kQyrW84wWmU5DT6kwFTysv1JJ9d4OTCQY7lcrkiAinVx8mMZ3EkC19YlrISKDBw3QCIePaE6476x2lqx6RHal9rmbBTGXzEwGWkTJWeL+PBSLaT6pdBx5TtS/lMgYa3XSZNMviaAhq3SadpKCf9yMSDj1RlwnGmpJPKke9y48RiIgpTW2XSxkmD24zUOxC5YYMnYpZ1auclX/cxvTQ3GAzixIkTCIfDyMzMBBC5O5D3kclvOanQKIzq4+3YsGEDHnnkERw8eNBRp4SzJpf4+Hj84Ac/wCOPPGI/pOUkMP8808iD0JqRAohYaNy2bRv69+9vyyGNt7S0FNu3b4fL5UK3bt3QuXNnuN1u7N+/H88++yxaWlrw4osvRmW3Z5JRnuMGwjNons2Z5oLpfr6TiHcklSGNm8rhr6zgTmnKPqSh80zPFGCkU8qAYsp+ZdDlfcoNnMqWmxGcgq5TAOdBS7aJ7uXk01YbpGu5zp0e8pT9J4OJDMymEaOpbhqpyDIlydH1ctQHIGp+n8vilARyPcrnofg1su+dyuLXmUZqsv9bI2gZmGWMASJfd0Q2ZoIkaZkA8REbkY8si/exlJ0njZJgeXu5n/I4wok3GAzaz4bJhMflOvU81ubNmxEOhzFkyBD7mCREU2IjR0GkQ36e7t25cyceeughHDt2zKhTibMmlzFjxuDee++NIBYnUONaG1kAzgvgMiDv3bsXgUAAffv2RTAYxJ49e9CnTx8juZSWluJb3/oWKisrERcXh+bmZlx44YVISUnB5s2b0bFjR/Ts2dOYLZuCnBNMWTo3ThkA6Tpu+HxY75QdSmelazjB8PlfGQzkSIiMnxu7aU5eBkXeFpNDyeAqCYccil/DrzORGn8Cnx+XOudtonOm53GcRl4mO5R9ytsjR14ySHC5WguOJoLnRGwiB/qfXpZJssldZqQDnqhwmAK0k37kFm9TUJXfnUYcMvBJXfFzPA60Jhe3I7kphMvDy5HP4MTFxdnrZ7yNcjqOt43DNMVlkoETjJx94P0HnEroiVzo7dacHJctW4bm5mZcffXV9o4103NEUh4eW6SOpS+Gw2EsWbKkzcQCnCW55OXl4f/9v/9nD7uk0toCk4HwwCKHZHRdMBjEq6++ivbt26NPnz72lAcHV8SWLVuwe/duTJkyBQUFBVi7di3WrFmD/Px83Hzzzdi6dStGjx7tmI04tU8GBlP7uJHze/h5PkXBs3oefMnR5LoKl4VnalK3pqk4qScpM52XWQ7JRQGcFpVN5fEyabpBbp3lQYgvXMtz3KmlQ5Ic3F54cCXIRWlub1ImOs5HjHK6jMsgpx5NOpYjGNkv3Ln5NJPJDkkuvghNgccUSM5kr1IOqQd+TiYqJrKX18ppOJmUcLsz6YX0JeXhuqR+4DMEBK4TCWlvdK3Ug0kumVTSd7muwd9I7UTIElI/9DsuvB5q76FDh1BaWopp06YhMTEx4vecJOR6pEyepF7In9xuN+rr67Fw4UJHmU1oM7mkpKTgiSeewMiRI6POSWVLyOHwmZid3wecngJbvnw5brrpJljWqR/i4i+a4+WEw2Hk5+ejT58+SE5ORr9+/dCvXz9YloWCggJUV1dj48aN6N69uy1HW5zPNEqR3+X0D98tI8sxTQHyNvD/eUZG3/k8MZGVfGEiv1caJ3ciClic5CnbrKioQFpaGpKSkqKcUDoN9RcnEx44ZbCRmZ7J8ehebg9cDzw48EBlcnA+DWAKcHQdffK+4zu0uFOaEhInG3cKLKbt2/x6GQB48CaiMS2QSz2bRkmy7aaRmJRFwuk4H41QP/Ly5AjNSZdOhMeJX45SpU0QqBye3fM+5WugcmpStpXbOfWBtBGTnlojGW4DXGeyTeFwGO+99x6uueYapKamwrKsqPff0T0SMiFyIm4qKxQKoby8PKqc1tBmcnnmmWdw5513RgXz1kiFhDQFNx48SZnkLDxzP3nyJLZs2YLVq1ejR48eyMzMtDNiPjXHA1pcXBx69OiB6dOn4/XXX8fatWsxePBgjBkzBqmpqdi1a5f9lLNpNEBymbIlea3JeKRBmAKZHHHw+rjT8Cw6GAyioqICjY2NaNeuHZKTk2FZFjZs2IDNmzfj+uuvR2pqqm0I8fHxyM7OjgjCfNGOj5ZMbQqFQli2bBl27dqFBx54IOJ6XiYP/rydMtjTJ2+nk4OZbIjuJ5Lirx2R/UeQ897A6YV66XxOQc00XSj7mwdFp8TDKdBxGaSOTbumeCIjyYfrlvcB6YG/NJWPnk2BRk7XmGTggdwE6ecmMjMdkziTnZB/BAKBiOftTOXLkQ1vr3xVvqzbVA7FLDlCl0TAj7WW4PA+oTjB7YA+m5qakJ2djczMTJvY+EyBXFaQpCjX6XhsNyUATiNAJ7SZXO67776zKtiUZUhFkkJWr16NZcuWIT4+Hl6v187AkpKS7J/87dmzJ5YvX44ePXrY5Z48edLRcLxeLyZMmIAePXpg+fLlWLp0KXbs2IEf/OAHyM7OtrPw1nCm863BtNBOZZoIiwd+WT/NA9fV1WH16tU4ceIEBg8ejF69etlD5vnz5+Po0aP43ve+B7fbjcbGRrz//vu49tprkZ+fD5fr9G4l+eAV1UWBh6758MMPcfToUdxxxx32kJvaJIMGgQIXgIhpS2ofbxd3OA5TFkXHpYM5EaMsS47knEaNVKZsI10nM3GTbKY+5HVz0qLnfqQzkw/wIEDgwYyXJ0mb+oKyWUkmvDyZGJiSLDkNSudN7eb3cvLjMI3E5L1ng+bmZsyaNQvXXnstcnJyopInOXqS9fARn5OPSp2YklPebjmy5bYlt2DLTSNyHYSfC4VCKCsrQ0pKCpKSkgCcSkz27duHxMRE5OfnGwmZfNjj8USNkE1tP9NO4NbQtuf4DZAZgaliUj69Apxe7EbnwuEw1qxZg/fffx8333wzLr/8ciQnJyMcDtu/6dzQ0ICdO3fil7/8JXbv3o2tW7ciGAwiKSkJu3fvRmlpKYBow6DOKSoqwt13343nnnsOGRkZeO+995Cbmwuv14vm5mZHpbV2XM7LtmZsXB4CGRf/4+d4uTwbcrvd6NOnD4YOHWq/INSyTr3+evz48Vi3bh327duHcDiM3NxcBAIBPPfcc9i2bVtEQDfJTP1E8hLhT548GampqfbvePO2h0Ihe5sk3c+P8dGM/J/IzCSHk70B0Zs8+HkuH52nlxDy+2m9iP7otfbk4Lwc7vz0Py9TOqS0Dz5S9fv9qKmpQX19PZqbm+H3+6MWyUke/nPEUj+kOz5y4w/S8TbJDR+yTXKKU9o5tYGIkL+cUSYJptGoU9ly56BTMD+bv9LSUmzYsMFuZ0VFBQ4cOBDRBj4zwvvIlNhJe5LXyx2ZfCRDfcT9gOua9zONuPg0N9mLJEIqPz4+HvX19aipqYHLdfqH4A4dOoS5c+eiqqoKwOmfdCZCam5uRktLCyzLQmJiYpT9msjyq+IrP0S5cOFCLF68GHfffTf69+8fdV52CIAoB2loaMChQ4fw4IMPYu3atfjpT3+KxMREZGRkoLq6GkePHkVjY6Ot6OLiYvTo0QNxcXHweDwYN24cnn76aTz99NPIzc2NkoHvHCooKMCtt96KP/7xj5gwYQIqKyvR0NCAtLQ0o+x8j7hsk2wLcPplgfy4nBpz0gsPhvw+ylzp0+PxoHPnznZ5VEZiYiL69u2LjRs34osvvkCPHj3gdrsxfvx4/PjHP8avfvUrXHXVVRgyZAhycnLsJ3glGZNh+/1+zJ8/H7fddhvatWsXka2Tbizr1O+iE6nLHTb8xY+1tbWorKxEKBRCWloa0tPTAQAtLS1IT083rhFwkGNQeXwhnxycrzWZMlW5MUBOS8rfUjc5Hc9IKXDz53XkaIKXV19fj3Xr1iEnJwfdunWLeDsDL5+TE5erNdLl7QVOjRj5O9tIZ7zv+CvmTQGMl2+aDuHycZ1xnZsSJ96XpqlS09RhMBhEbW0tKioqEBcXh9zcXCQlJUUkGoFAAB988AESEhKQnp6OlpYWLFy4EOeffz4KCwsjkgWuM6e3WXPIPpK2xHfmmUYs9MlHjZwQCLxcSoICgUCEL3HdnjhxAsnJyRH3DRw4EDt27MBLL72Eq6++Gueddx48Hg9crlO/o5SammongjyRbW1jk5MNnAltJhfeuI0bN+Kb3/wmDh8+jPfffx+zZ8/GoEGDou6RC9lc0FAohMbGRlx00UXw+Xz43//9X6SlpeEnP/kJsrOzsWPHDjz//PNYt25dxI8xceVfdtll2LRpE37605/a011OGdDBgwfh8/lQUFCAkydPoqWlpU0OK5XKDYb0IadYnIKMKdvmkM4p66SAYQoAKSkp6Ny5M06ePGnXl5eXhzvuuAPPPvss/vKXv2DPnj3o168f8vPzkZGRgZycHDur4dnc0aNHkZaWhgEDBtiOy9vNAznfCssz5ObmZhw9ehRffPEFPvroIxw/fhw+nw9FRUXIzc3F2LFjUVFRAcuyMGDAADtYcP3LgGMK2jJ5kVNInLS585v+l/fItRaT3sk2SY+yTrpn3759+Oijj/DQQw/Z20klcVE90tG5XXH90HH+yesn+fx+P1JTU20ipKkRXgb9L5MeU1JE5F5WVmZvgx0zZgwKCgqi9CP7h2SSOuUBXM4MHD16FC+//DJ27NiB+Ph4jBgxAjfccAPatWtnB96ysjJs2LABV199NdxuN44dO4bm5mYUFxdHTP/IJ91bI0/TMa4rAsnLR3Ty2SeZOEidSHLn15C/8Y0p4XAYq1evxo033hihu4yMDEyfPh3Lly/Hn/70J3Ts2BETJ05Ep06d7Pt5u3n7efmt6aGtOOuRSyAQwGuvvYbDhw8DAA4cOIDrr78e7777LgYOHBhhsHxnEHcgakxjYyM6deqEbdu24dixY7jllltQWFiIUCiE2tpauFwu+Hw+1NXV2fecOHHCXsxPTk7Gd7/7Xbzwwgv4/ve/j6eeeso4ggmFQnjxxRdRVFSEpqYm+P1+5OTkICsrK+pa6RBOyuUkwjcjyGDIy5BTLfyczIx5p5ORmoIvGfLGjRvh9XoxcOBA+56EhAT069cPkyZNwssvv4xNmzYhFArhxIkTSEtLQ3FxMc4777yIMuPi4uxt2gkJCRGO6ff7UV5ejvr6euzZswd79+5FMBhE+/bt0alTJ2RmZiIuLg6VlZXYsGEDli5dirKyMvTp0wcXX3wxioqK0LFjR+Tk5MDtdqNdu3Z49913sWHDBkyfPh3t2rWLCLo8o6KMVy48yoxTbk8Hol/fwfvUNIXFZZDTVnQP9TONLILBIBISEqLWNKgPGxoa7N9g4TbA6+dBlycopl/Q5N/5tCTvK8uysH//fsyePRsXXnghxo8fbxwxcZlNyRSBZPb7/Th+/Dh++9vf2skK7VSUGyikrk1Tl7y/ZcLn9/uxdOlSLF682JaturoamZmZGD58OLKzs1FdXY33338fe/bsweDBgxEKhbB69WpcccUVEQ9I8zbztp1NADUlhGSTfGcZ91c5WgKi3/lHZZuSSh5n6J7Kyko0Nzejc+fOET7hdruRlZWFSZMm4aKLLsKcOXPwyCOP4JFHHsGgQYPstznw0TzZMidE2V7T2t+ZcNbksmvXLrz22msRxw4dOoQ77rgDH3/8MdLT0yME4mTClRwKhbB3717k5+fD7XajpaUF7777Lo4dO4Zdu3Zh+/btiIuLQ0FBAcLhMI4fP44DBw7g448/xvjx4+2HhZKSkjB58mTcfffdWLNmDSZOnBjF+uXl5Th27BguvPBCZGVl4fDhw/YDR0D0U72kVJPRycBjerqXByvpODyIm+ohQ+GBUGaNnKRDoRCqq6vx6aefIiMjw96oQHV7PB6kpaUhOTkZxcXFGDVqFDp16oTk5GT4fD5bBkJzczN27dqFe++9N2LY7nK5sHXrVjz11FMIBALw+/1oamoCAPsdV5RFkl4uvfRSXHDBBcjOzkZlZSXKy8tx9OhReDwe9OnTB+eddx6mTp2KjRs34je/+Q0mT56MPn362NNk3GHD4TDKysqwcuVKXHvttcbfEpG65598CkYGFT6q4fcQsfBpQeo30sGhQ4ewbds2HDx4EO3bt0e3bt3Qu3dvpKWlRTip1+vFyZMno9Y4qEw5WuWZvWVZ9mhDBiq6z+12235E5dbV1eGTTz7B8uXLccUVV0TYOd9qLu1ejsR5PbRGsHDhQlxyySUYN25cVBDk+uLJiYlw5KiJj/gs69Qrnnbv3h01LXv06FFUVVXB5XJh1apVeO+99+zRc21tLcLhcETyyPtdvgaHJwscJI8MrNQfdJzLL/tFfud9S7FDxhBps263GwkJCXYsq6qqwuHDh9G3b187DnIio88OHTrgjjvuQKdOnTB37ly4XC4MHjwYtbW1qKurs4mIfhtI7r7ka1RerxejRo3C3//+d7QVbSaXn/3sZygsLMRPf/pTVFRURJ3fvn07PvjgA9x4440RbExOK404Li4Ow4cPR1xcHDp27IjRo0dj2bJlWLhwITp27IjJkydjxIgR6N69O8rKyvDWW2/h/ffft3dCBYNB+1mXlpYW+7dkZJZC22nPO+887Nq1C126dEFWVha6d+8elUHKXTNcXg4yOnq3WUNDA1yu079nY2J/mTXL0ZEpk+XBjZMTz2T9fj/279+P/fv3o3///ujSpUvEg4UtLS34/PPPUVxcjJtvvhkdO3aMCgZcntWrV2PAgAFISUmJMrZevXrh8ccft0mdpkeam5vR3Nxst4fWzbKyspCUlITS0lKsWbMGa9euRXl5OWprazF69Gjcc889yM/Px+DBgwEAL7zwAm699VYMHjw4yvkpM66rq4uwJd4GghwhcmeR02Gyj2QfmwJhOBxGZWUl5s2bh5UrV8KyLOzcuRNXXHEFPv/8cwSDQQwcOBA33HCDvaZXWFiIlJQU1NTUoH379lF9zuUCTo10jh49im7dutlJhNfrjXj9EY10ePCh9Zbm5mbs3bsXmzZtQiAQQLt27Wx7ISLi9sUJndsetzv63tjYiKNHj9q+Lkc9fHOBnNI809y9DNQkK7Xb4/GguLgYAwcORGZmJpqamrB3717U19ejT58+qKiogN/vh9/vj3hzB+9LuaBv6mve56Qj+s7tik/Zc7vj73uTtsx1Qi+brK6uRlNTk32vy+Wyd4hWVVXB6/ViwIABeOedd/DJJ5/A5XLhe9/7XkSSyfuLyMzn8+G6666D1+vF66+/DpfLhdLSUqxevRo1NTXo0aMHbr311ogXUfLkleRJTEzE1VdfjY8//hj19fWt9iGhzeTy+OOPR7zZVYKymSlTpkRkHjI48w6kzs/MzMTjjz+OK6+8Em63G8XFxWjfvj28Xi9cLheampqwYcMGBINBbN68GT/84Q9RUVGBEydOICEhATU1NfD5fBg0aBDC4TAaGhpw/Phx5Ofno6qqChs2bMCYMWOwZcsW1NXVYcqUKREBnBySy9zaEDAcPvUG0paWFgQCASxevBhZWVkYPXp01HCTt19ObfEgKQmIDJBGAQAiFml5HRUVFWhpacEdd9yBlJQUe8QRDodRUlKCgwcP4gc/+AHy8/MjZOF9Eg6H0dzcjM8//xy33357RP2kq8TERPTu3dvYr7xvaZqI9Jueno6rrroKF198MQ4ePIiPP/4YK1aswKhRo9ChQwfExcWhX79+OHnyJF5++WUUFRUhNTU1IptyuVxo164d8vLyIvqJBwieuDiRtMvlivg5ap5UkOx8GlL2CdWxe/dubNiwATNnzkRhYSGefPJJ9OrVC9dffz3q6uqwdu1avP322/a2WJ/Ph6lTp2LJkiWYPn26XScP5vQ9Lu7Uaz6WL1+OXbt2RUzv+P3+CFviIynaYBAIBLBt2zYsW7YM27Ztw4UXXojk5GS8//77qK6uxqRJk6KeBZHrUqR7uRZCm2soa29paYnaacVfqcIJRWb2cpZAEjzZ3KBBg1BSUgIAGD58OEaNGoWuXbvC7XbbyUZhYSH69euHI0eOoEuXLkhLS4Nlnfp13AMHDiAQCCArK8t+Y7DcRUcEa9o1xkdNXOcyIaX1rUAggJqaGuzduxcNDQ3o2bNn1KumKOFuamrCl19+iVdeeQWlpaURmx04CXk8HjsG33rrrXZSU1lZCbfbbft9ZWUlgFMjZdoQkJmZiZEjR2L79u34yU9+goaGBrRv3x4jR47Ejh078POf/xzf//73kZeXF/WDdjRKi4+Px4UXXogLL7wQy5Yti/J9E9pMLnx6q7Vr+FCS38d3X8khqMvlQl5eHq688sqIbJQHjyNHjiAjIwO5ubm47LLL0L59e6SlpWH9+vXYunUrHnroIaSkpGDRokWYPXs2JkyYgFAohOeeew5FRUXYvHkzqqurcdttt9nv6gmFQvjoo4/w2Wef4eabb0ZhYWFE4DGBFB4fHw+fz4eSkhK8+eabmD59ut3G6upqVFVVoUOHDjZBylELz+po9OXz+eyF4bq6OuzcuRN1dXXweDzIz89HdnZ21HvU3G43jhw5gsGDB6OwsNA28vr6emzduhXvvvsuxowZg969e0dkUDJLtywLVVVVSElJQXp6elQmxzMi7nBO2zHJeUKhU2/ubd++PXJzc9GjRw/k5+ejrq4O8+bNQ79+/ezXCQ0ePBh///vfsXDhQtuY8/PzI3bL9OnTJ6J8uf5CNsadngc3sj1J6HQt32LKM0CpD9rwQG9+GDRoED755BOMHDkSnTp1wlVXXYUTJ05gwYIFuP7665GWloaioiKUlJSgpKQE5513XtQaANetx+PBtGnTsHHjRpSVlaFjx45RI1geqHkS8Nlnn+Hdd9/Frl274PV6MXbsWHzwwQdYtWoVvF4vrr322ihCkSMGviXbZCepqakRx4BIEuftkYTB5aZPEwFRW88//3z4fD4kJSWhsLAQWVlZtk3QlGzXrl3Ru3dvlJSUID09HTk5OQgGgzhw4ACefPJJBAIBXHXVVRg3bpy9jZ/a39LSguPHj6OmpgbAqWlet9sNr9eLdu3awefz2VPzNTU1KC4uttcjuQy0saOlpQU7d+7Ea6+9hiNHjtg7BC+88EL0798fDQ0NdqxxuVw4ePAgSkpK7E1GiYmJ9lZyQnx8PGpqanD11Vejvr7eXlaYO3cukpKS0L17d5SWluL48eM2qdCoqkOHDrjppptw2WWXYdGiRcjMzMT06dPtNddZs2Zh0aJFmDp1KlJSUoxJFfXJtGnTsHLlSrQFMfslyri4OBQWFkYZFF+XkPPLdB0PegS+MEiZwFNPPYUpU6YgISEBLS0teP3111FVVYXHHnsMFRUVeOKJJ+D1enHrrbfi2LFjePjhh+21hueffx73338/8vPz7S20u3btwhNPPIGtW7fC6/XinnvuQUZGhnG3DhDpeABsQ2psbMT69esxevRoexv1j370I/Ts2RN33303srKyopw4HA7jwIEDCAaDWLFiBQ4fPowHHngA7du3x6ZNm/DKK6+gvLwcycnJOHbsGPLy8nDbbbdh0KBBETuTgFNP6l500UVISEiw1wF+9atfYfXq1UhISMCDDz4YEbi4rnlG5vF4bEeic/QnF5u5PjjR8YyXOwfPiAsLCzFw4ED89a9/xcaNG3H55ZcDOPVTDu3atcMf//hHjBgxAsuWLcNPfvIT5OXl2fXl5ubaoyx6Glv+rK0kCpKJy0PHqT9p1xs5pMxQ+XMZwKnfMmppacHevXtRVFSEvn374sMPP8T8+fMxffp05ObmolOnThg5ciSWLl2KiRMnIi4uDl27dsXf//53XHvttRG7q0x9AgAXXXSRXTdNxXL9WpYFr9cLn89n+9jmzZuxdOlS+P1+5OXlYfHixejcuTMuvvhi+Hw+u4+JnHlGTesqcm2Kf6+vr0c4fGorLE2Byq2tkqw45FST9C9+b1xcHDp16oTc3Fw76PP1Np/PB6/Xi9raWhQWFmLp0qVISUlBWloaQqEQSkpK7PjR2NgYkZxR+QkJCUhOTsbmzZvx8ccfY9euXWhqakJGRgaGDx+OiRMnIisrC2+++Sbq6urQpUsX3HDDDQiFQli/fj2qq6sxevRodOrUyR5FXHjhhcjJycHOnTvx2Wef2QnbwoULceLECWRnZ+POO+/E9u3bsXXr1ohkjZ71q62ttXXR0tKCQ4cO4eKLL0Z8fDzatWuHnTt3ori4GElJSTh58iS8Xi8mT54Mj8eDI0eOwO/3o1OnTvB6vdi3bx/69OmDoqIi9O7dG8OGDYPP50NGRgaOHz+Ojz76yF6GMO16o2NdunSJ+u0uJ8SEXNxuN0aNGoWHH344wlC44crskbItIhruzNz4wuEwSktL0dDQgCuuuAIejwd+vx8vv/wytm3bhptuugl/+tOfUFZWhjvuuAP79+/H2rVrsWfPHrhcLjz88MN46aWX0KlTJ1x22WUoLS3FkiVLcN111yE9PR0jRozAwYMH8eabb6JLly4YP348MjIyIobtcvjOA6jL5YLf78euXbtQXV2N5ORkJCUlISkpyZbzvvvuQ3JycsQT8keOHMF3vvMddOvWDQMGDEAgEEBKSgr27duHv/71r5g4cSL69++P0tJSvPDCCzh+/LhxSoeG1ikpKQiHw6irq8Mf/vAHHDt2DA899BDeeecd+71D3Fh4P1GfpKeno1OnTjh+/Dg6duwYtaNFrmVwyClAGVQ4uXo8HvTs2RNpaWnYvXs3xo0bZ1+Xnp6OoUOH2v22d+9e1NbWoqysDBdccIFdxttvv43169fj4osvxsiRI9GxY8eoqU0+QmlpacGGDRswaNAg+P1+HDlyxHYkbo9yXYZkl9t4ExISUFRUhD179qC+vh49evTAhRdeiA8++AAVFRWYNm0aiouL0bVrV3z66af49NNP0a1bNyxcuBA7duxATU0NbrrpJvtJal5HOBzG0aNH8fOf/xz9+/fHjTfeCJ/Ph5qaGvztb39DRUUFkpKSkJiYiLy8POTk5KCoqAg5OTmwLAt9+vRBv3798OWXX6KyshKpqakYPnw45s2bh+985zsRu4Lkb9nQyJevn9TV1aG+vh5VVVXYu3cvtm7diu3bt+Ozzz7DDTfcgKKiInTu3Dmivzlx8P9Nu+9Ix6YRDt1LO/HkrAcAZGVlwbIspKenIzExEdXV1fYT+lu2bEF1dTX69euHESNG2IHb7/fba6Xp6elIS0vDqFGj0KtXL5SUlGDDhg04ceIE8vPzkZKSAss6tf5z11132ZsMSkpKsGLFCgwbNgy/+c1vMGnSJFx44YWIi4uDz+dD7969UVxcjCuuuAJbt27FoUOHcOONN+Kdd97Bvn37MHfuXOzduxeWZaFbt27Ys2ePTZbhcBherzdiwf7TTz9F3759ERcXh7q6OiQmJtqjuu3bt9sjn3bt2iEnJ8fW4cmTJ1FbW4uGhgY7FqWnp9v6bN++PY4cOWInbDTqSUxMjEjAXK5Tu3dp/e5MOGtyiYuLQ//+/XHLLbfYvx0QFxeHLl26oF27dlEGJjMRngFxg5IvXKTr6TUmEydOtA1m9erVeOutt9C5c2c89NBDuPnmm/HAAw9g9uzZ6NmzJ/Lz8/HJJ5/gwQcfxLp16+DxePDUU08hGAzij3/8IxYvXozi4mLs27cPFRUVGDhwIPx+P377299i//79uOGGG+w5XZ69y8zK7/djy5YtcLvduO666+yn4nfv3g2Px4PBgwfjxRdfxPHjxzF27FiMHz8ewKmRxnvvvYempibk5OTA6/XiuuuuQ11dHd544w1MnjwZvXr1wr59+/Dee++hpKQEd9xxB4qLi+3XzxP8fn/EL8OVl5dj9+7dmDlzJgYPHozly5dH/LaDdGA5PXnxxRejvLw84oetqN9NI0xZlmVZ9kJkeXk5vF6v/fwRBVFqQ2VlJbKzs23HBU7NsXfu3BkZGRkoLCzE8ePHMWfOHOTm5uKCCy6wdf7JJ5/gsssuQzgcxrx58+yyCgoKUFRUFNF/VG7Hjh2xdOlSjBo1CgsXLkR+fj4mTpxoL5Rz4ja1kxNMOHzqZ3wLCwttR7/00ktx6NAhrFy5Ert378YDDzxgk9lHH32ETz/9FOPHj8e4ceNQXV2Nrl272kEuLS3NXgR2u93IzMxERkYGxo4da28rTktLQ1lZGZYvX45OnTqhQ4cO6NevHwYOHGj3V1xcHHr16oVBgwbhwIEDKCgowFVXXYVly5bhuuuusx+io+kXnjTwtTryvZqaGtTV1dkj9OrqaqxZswZjxozBpEmTEAgE8OKLL2LSpEno1auXXabUHxE3zUTwBej6+nqcOHECPXr0gNfrjbqPQ8YHAPaow+12o2vXrpg3bx66d++OxsZGHDlyBKmpqbjqqqvsqSjahPLll19i586dGDduHAoKCuDz+VBYWGi/r2v+/Pk4dOiQrS+fz4dgMIiePXti27Zt+OCDD9CjRw+MGzcOJSUlWLx4MYqKipCRkREha1JSEgYNGgSfz4e1a9di+vTpeOmll+D3+1FSUoLrr78excXF+N3vfoeSkhJcc801KC4utnVZVVWF9PR0bNu2DW+//TYmT56MvLw8JCUl4YUXXkBOTo49Qjl48CD27t2LqqoqhMNhe2MN+RS9KoZ8IyEhAQkJCcjIyEBlZSV27twJl8uFgoIC++FLIpa4uDiUl5dj//79jjGA46zIJSEhAbfffjuee+65CCPgWSufOuHBmP/xgM3v54ZtWacWLz/99FOUlpbi29/+NlwuF2pqavD666/jmmuuQUZGBnw+H0aNGoXnnnsOt9xyCwYOHIjHHnsMubm5WLRoETZv3ow33ngD6enp+PDDD+Hz+ZCSkoKXXnoJpaWlqKqqsudzGxoa8Pbbb6O8vBwPP/ww8vPzI6ZC5Dx3VVUV/vrXv2LgwIEYNWoUSktLsXnzZhw4cABTpkzB9u3bsWPHDtTW1qJr1662fiorK7FmzRpkZ2fjggsuwOeff46RI0di4cKFGDFiBHr06IHFixfjzTffhMfjwZVXXomRI0fC6/WisbERzc3N9kLe0aNHkZiYiKNHjyIYDCI5ORnx8fE4efIkMjIyMHPmTNuZaEqAt4c+Sf8UhGnUKXfBSB3wvqPdSiUlJZg9ezZ2796NTp064fLLL8eQIUPs+vfs2YMPPvgAAwcOxEUXXRTxm9+HDx/GoEGDYFmnXt9RVlaGzp0729MK+/fvx0cffYR77rkH559/vv3cSDAYRENDAz788EM89thjePzxx1FcXGzbInBq40hycjKam5tx6aWXYtOmTZg7dy5uvPHGiC2lEtJe+QaAxMREpKWlwe/3o1u3brj33nuxYcMGrF27Fi+99BJycnLQpUsXZGZmYseOHSgsLMSRI0dQW1trL0iXlpaiS5cu8Pl89lRXamoqsrOzkZycjOzsbNTX1yM1NRWTJk3Cl19+ibq6OiQnJ+PAgQMYOHCg/U6+cDiMlJQU9OnTB0uWLMGkSZOwevVqDBo0CAMGDLBtkDaH0B/fdk4PzQaDQTQ1NSEpKQm5ublwu93Izc3FihUrcO2116KwsBBvvfUW7rzzTixcuBBz587FtGnT7CBOPlxdXY09e/YgLy8P+fn5aGpqQmVlJaqqqnD8+HFs3boVW7ZswQ9+8AOcd955UdNivF/omR5ugx06dLC3YPfv3x9vv/02tmzZghUrVqCkpASdO3dG165dI37rhKadduzYgR49ethrjfTLnklJSTh+/DiOHz+Ouro6e4S4fPlyzJw5E/n5+UhISMCePXswb948VFdX45prrrGfmCfwKeZjx45h3rx5GDZsGDIzM3HBBRcgPz8f+fn56NatG5544gksXrwYBQUFGDBggL37lDYb9OjRA36/H8OHD7dfYjtx4kSkpqaiW7du9pZiqo98lRIn7sNkz/Hx8ejYsSNSUlKwZMkSDBo0CBdffLE9wuNl+f1+LF++3H7G8UxoM7n4fD5885vfxP/7f/8PHo8n4pzM6HnnywVfOV0iyYYCWV1dHWbNmoXPPvsMTzzxhL019ssvv0S7du1w3333Yd68eTh58iSefvppezdSMBiEx+PBBx98gJycHFxxxRXIyclBZWUlXnnlFaSkpKCsrAz5+fno2bMnSkpKsHXrVtTU1NiLzwUFBfYiqlwEpz964ebhw4fRp08fPPPMM8jNzcW4ceMwaNAgrFixAhs2bMCjjz6K999/H3379kVNTQ0qKirsTQTnnXceXnvtNUyaNMnOEvv27YuPP/4YL7/8Mi6++GL0798feXl5KCkpwaFDh3D8+HE0NDSgf//+6NOnD9avX4+RI0di+fLlaGxsRG1trZ3JXX/99cjNzcV7772H6dOn2y+r49NFfB2MyJ2vw5CB8V/io2N8SoV2ES1atAjLli3D6NGjMWHCBOzfv99+i0NaWhoaGhrs0e/VV1+N9u3b2wHj0KFD2L59O6ZMmQK/34+qqio0NjZi/PjxCAaDOHjwIGbNmoWpU6faZM3ftJCSkoJLLrkEy5Ytw8mTJ9GrV6+oqb3Nmzdj6NChKCoqQllZGbKysvCXv/wFN910k/EH8DipkH7IRikbpwyT1jjGjh2LvLw8zJ07F19++SUmTJiAVatWobCwZ5rxKgABAABJREFUECtXrkTnzp3hcp3atLFw4UJ8/vnn6NatGy655BL07NkTPp8PlZWVqK2ttacoXn31VUyaNAk9e/bEgw8+iM2bN6O0tBQffvghCgoKMGbMmIhNIkOGDMF//dd/Yc+ePejQoQMuueSSCJ/ji/Vk0zyJaGlpwYkTJ1BdXY127drZC73Nzc12Fk9Tsunp6bjgggvw2muv4ZNPPsHKlSsxbtw4dOrUCVVVVVi+fDm2bNliT7sWFhZi37592LJlC2pqanDBBRdgwIABqKqqwueff47OnTujsbHRniLy+/2oq6uLiBH0nFFSUhLy8vLsdwV2794dw4cPh9vtRv/+/TFy5Ej89a9/xbvvvoubbroJ6enpqKmpwdatW+3nYf7whz8gMzMTiYmJiI+PR2ZmJhoaGnDkyBH07t3bDsIjRozAwoULEQwGkZmZiVtvvRUvvfQS9u3bhxkzZtjroc3NzRFTnHzaOTU1FR6PB126dEFdXR3Gjx9vn+/QoQNuueUWhEKhiCkp+szOzsbMmTORlJSElpYWVFdXY9SoUbadSiKWybopKaRZp8cee8xeq0pMTIxYAgBOPfA+e/ZsvPbaa63OXnC0mVx+//vfY+LEiTaxmObUeaOcRihA9ENEdI4UUVNTg+effx4nT57Ef//3f9vZTDh8at/2lClTkJKSguHDh2PXrl0oKirC9ddfb8/LzpgxA5dffjmOHj2Kzz//HCdPnsQXX3yB5cuXY/DgwfjFL36BYcOGwe124+DBg/jb3/6GRYsW2a9OoVeUmEYs5Ji0fXnMmDG47LLL0KdPH6SmpqK8vBxLlixBZmYmvvOd79g7Rt555x386U9/gt/vR3NzMzp06IDGxkb7QcMvvvgCI0aMgMfjQXl5OUKhU0/d79ixAx6PB0lJSejQoQMKCwtx+eWXo6CgAPX19Rg5ciSSkpLs+fQhQ4Zg4MCBmDVrFp555hkcP34c9913H9LT0yOeWyF985dV8rZyQ+VOzae1+LRZMBjExo0bsWbNGjzyyCP2Ivz555+PcePG4eTJk6ipqbHXCWh+HDiVKVdVVeHjjz/GuHHj0LNnT/uBsZ49e9o6LykpwY033oiCggJUVFQgEAjA5/PZz3icOHECH3/8MTp16mTbDA3rKSCtX78eV1xxBTp37oy8vDxUV1cjKSkJK1euRGZmpv0ciNfrRWpqqv3WWe7sRKackPlIz+v1IjMzEx6PB01NTbAsy97tt2PHDoTDYRQXF2PXrl3YvXs3hg8fjpaWFixYsAAejwe5ubk4fvw4MjMzkZWVZZOvx+NBQkIChgwZgqysLBw8eBCff/453nnnHXv7Pr1g1Ov1omPHjtiyZQtuuukm+zkhelmm1+uN2BknR7HAKbJOSUmBz+ezs+j4+PiIZzvq6upgWRbat2+P+Ph4XHHFFfjwww/x61//Gt/+9rftqaCsrCzccsstWLBgAX71q1/B7/cjJSUFV1xxBS6//HLMnTsXH3zwAUpLS5GQkGCvpdHobtOmTfjiiy/Q0NCAlpYWeDweZGdnY9iwYbjwwgtx7bXXoqWlBSkpKbjuuuswZ84c3HbbbfB6vSgsLMT//M//4LXXXsOAAQOwadMmxMfHY+LEibjooouwZcsW1NfXR2x2qKysRF5eHvr162cnttnZ2Zg8eTJCoRASEhIwcuRIFBYWIjExEZmZmREbDWRcdLlc6NGjBx588EGkpaVhyJAhAKI3x9CuMx4nuQ96PB7bb2ltmPszj8FyHZTWimVcdrvdEWtmfF22pqYG69evx5tvvondu3c7PopiQpvJZdq0aRGCy/8lm5m2iPJGyV9sA04v4Dc2NuKKK67AoEGD7Ok3CmxDhgyxO7F79+740Y9+ZM8dkkJ69+6N888/H3v37sUXX3yB5uZm5OXl4dFHH8Wtt96KnJwcu7x+/fqha9euuO6663Dw4EHExcXZvxvDHY3kp4Dqdrtx5ZVX4sorr4wYaufm5uLWW29FYmIiamtr0bdvX3To0AHJycno0KEDCgoKkJKSEjHPX19fj06dOqFnz55wuVyYMmUKxo4da89Nh8On3hKdnZ1tz5kDpx4oy8rKgt/vxwMPPICTJ09i2LBhCIdPPeRYU1ODyZMnY+jQoRHZi2l7qUwWuBFyY+NlkJFb1qmXkC5atAgzZ860iYVAW0gJVH9LS0vEm2EnT55s79arqqpCIBDAddddhyNHjmDdunUYNmwY4uLi8Jvf/AZ79uxBc3MzMjMz4fP50NjYiC+//BINDQ3Iy8vDkSNHcP3112PkyJG2vR04cMBe3ASAjh074sMPP8TQoUPx3HPP2TtvvF4vcnJykJ+fj/bt29vt4W+R5Xrio3Ta5k5/hYWFcLvd9ssqaao1KSkJb7zxBi6//HIMHz7cHskcP34c+/btQ1FREfr37w+v12svqBMxeDwe5OXlIRQ69UNuO3fuxJo1azB+/HjExcWhvr4eaWlpOHToEHJzc9HS0oIjR47g/fffRzh86nfWBwwYYK/x8KSP+tbj8aB9+/ZRPtypUyd0794dDQ0N6NChA7KyslBVVYWCggJ07doV69atQ8eOHTF37lzs3r0bgwcPRnx8vD3Cuf7661FaWoovvvgCvXr1wujRo5GZmWm/e+7+++9HTU0NBg0aZE95pqeno0OHDrj00kvt7cDJycnIy8uz16qGDRtmy9q1a1fcdddddrsKCgrw4x//GEuXLsULL7yAnj17YsaMGfYDxd26dYua9iW756+0cblc9noKJWAFBQW2D1DM4zM73F6ys7Pt2ENvcDBNu/OpZumnwOmdtCkpKXYdvByZxPMpX74TTE57cYIie3z88cexbt26No9WOM7qORc+b0cOSwJLluT3OR3jwZv/fkVBQQEKCwujnr7mU2x8uyl95zt9AKBz5874+c9/joSEBHTu3Bn9+vWzFclfo5KcnIwhQ4Zg6NChAKJf/0GQGYnb7bYXW+lYYmKiPSSmhUSqT651UGfSMxNxcXHw+/121ilHfzzLoe+kH3qvG5V9++2321M2/D7ePl4WJ3jg1HbT2tpatG/fPmKtQU6nUMCjNQHaZWbKhKlu/kcLirTQSPelpKTg0UcfRW5urv0Us9vtxo9+9CNcfPHFePjhh6N2zpGey8rKsH79ejsQ0O6rBQsWoE+fPvYDdg0NDaitrcXnn3+OW265BaNHj7ZHBzRKMU2Jmdag+Gjv+PHjWL58Oerr61FQUBAxZ+31eiOmpfr06WMH+czMTGRmZqJXr152u2gEt3XrVlRUVNgbIHw+H/Lz89Hc3IzS0lLMmTMHK1assJ+puOqqq5CYmIjZs2fj1VdfRceOHXHRRRdh/PjxyMrKivAbOe1LvmTy3fj4eAwYMACHDh1C9+7d0adPHyxfvhx33nkn7rjjDvzmN7/BmjVr7L5JSEhA3759sX//fliWhczMTDz66KM4efIkEhISkJeXh8TERAwfPhy5ubkoLi62fYsnqPReNuo7siW+y5QHTNohSe1LTEzElVdeaW/l5e94M2124YGZl81jA79XzgA4QQZpOStCn6bHIfjIghMg1cuTPTrWWjIpSYzbdV1dHZ566imsXbu21fa0BpfVRkqid9GYOoAawhtgOi7Pma7hzxg4icaZlpcpO4SPjiRJcUgGpzJ5UOWdwp8z4PfSH3/uwrJaf206GQrfRst/E11OK/K2UKCj62khlvRHDkplyelIck7uMKHQqbdV/+lPf0L79u1x3XXXwefzRbSJB1haRG5oaMC+ffvQu3dv+0lx3re8z/j/nHRJ73zdx7Is1NbWYteuXfaU4qWXXhohN+mCkzB/wLKlpQXl5eX2tFyHDh2QkJBgbwn2eDzo16+fvYgppxT4dKIpEFD9brcblZWVeP/997FixQrMnDkTw4cPj+hrKjcQCGDZsmW49NJL7aepZVAg/fr9fuzevdveGMCf3aGRfkVFhf1cVNeuXeHz+dDc3IyNGzciEAigX79+yM3NbTWgcmJpLUju37/fJpTGxkbMmTMHN954Izwejz2SCgaD9s6r2tpaezcYTevw5JBP2ZEf0PMs0r+4nggUl/jMghxx03V8xC11zvXAkznqO7lNnXTFfU2WJSHtRv7P44gpxvHv1F7el9KfJJyIhtpC2Lx5Mx5++GH7jRBO7WgNZ0UupvlZzpx8VCEDF13PjYoP5/j1Tpk273Tp7HSdzMjovPzxJakgOQyVyuadQgGdy0fGzHdmyCAlQcNufg3XKXcs/p3rjrbFUrChcvlr3XnbZEYq66UHw55//nn85Cc/QadOneByuaJ2m9BUFpVLc7HkhORw3AFIbr4N1ZShyf4kvdJ6iNyQIAlYOq4MqHRtS0uLvTuI61SOgvl0Ebc7aZ8ulwu1tbU4duwYMjMzkZeXF0EUPEBRf7pcpx9Q5SRGfcX/uHz8f3q3mJzyoH7j9fEEQ9qW9FXp77zvjhw5Ym94oX7hO9BMdZp2kHIdSxmk7dIxPtqicmXfk75NSZTJ/zl4sJY+TgkRn67mttJaHdyGTJBy8hgkE2hu09Qn8tUt/D7qT94mTvJETIQvv/wSDz74YNTsDW/LmdDmaTHeaLfbbQdr2llAyuFGyR2HOoW2nVLjqFGcpekcZS8mA5M/DiUbK7MLDrmDiOqj+/j9QGRHyiBDbaVAK4elBCcZqR4+TScDsIkMuAxc77xt1Fd8n7qUgZMvGdvevXvh8/nsKQsyYJkNyulNGVCkHnhQNC1+cvDdNkQofDQkCZvrQm5GMPWhy3X6OQ8TUbWWePBjXP+WdWoLMS1+c7m4LfFAwZMe01QVl4fLTuc4gfP2SblIl6b1M9I1byPpWgZosjFKOoDTvwPCSVkmnvK71A8d5zFB1s/7UcYKXo9MJOT1vAxTksATNRmQqT5J3Kb+MvX7mRJOOWrncnE7kL7IbYC3k5fLCYbA5af+s6xTT+L36dMHmzdvNsrZFrT5Z475NBDfKcQ/5Y8AUSbMz/PsjJ/nbCqDPn/9hczwTEGbdwo5lWnUZYJTWfJ/GUhlliuvo/+5YXH5edt4e3nd3HF4oCBnoFEMN05elikLM5EpTV/s2rUr4rdCWus3kpFPw8l+k4FOBi2ZpXPdcB1Kgje1j5xE2o0c0ZKTcr3LoMCzQ4JsE3CaEPkDmdJGeb9yu5F9LIOntBUAUbqibctyzQuI3Hgg5SY5uP7pXlPWL32fyy7JSN7Dy+V9SfGByNYpwzf5jtSTk3xONsTL44mwU+LK4wlvj6mveLncf7nNUZ/xn9um/jX1Fx0jn5c+aJJZEjwdk+RCdaWmptrbsL8q2kwuklhoZwwJxqdJKIDQcJ1+64Nvs+POwLOuCOFEgJAdJYMLD7hOmS11sMlwZVCR1/IRAv/OsxwZFOWnNCwqh8sgF81NkCMtOkajKP5+KNOUgBPBuFwu9O7dG1OnTsXBgwfR3Nxs38/fGsudhQc8yui4Y8j287p48DY5nAyKkpScyIY7vAwsbQncrfWfDHzcJng9JvuUwa4tdkifnAD4dVLHEqRPXhYPMlJGU0IgycOUrHAi42+F4MFatlHaBYCIvufXS5uVfWkaoZiIRoLLb4pDsmw+muGjBbpGJt88ieC+zSFlM8UQmdTxfnRqm5RfJkpOerQsC9OnT7c32nwVnNVuMd4JfBqHGzVXNl+YN2Up/DgP5ryBHCaG5tdS+a2tq5iyAFmHaepABiu5Q8VUr5OzS/n5aEPWyWXn7eFtl+CkzDNIqT8Juj4hIcF+jxdw6gfETHP33LDPFMi540rCk+2QZMV1QnWSPHx0JJ2fZOTrTLIeDt4f/JipL033mrJA7jP0x4OTU6LD/YWPUPg5KbMsi/Rjsifg9PqY1Au/n8CDs0wQTIkL14M8JnUrEynqZ+lT9F22w5RMAtFTWnQ/r1sSpGm0IssmO6byaU2QT6eZIH3WSec8vpgImZdFNi6nmZ1GHCQ71znFCO4vLpcLqampmDlzJp5//vmzer6FcFZrLiQcd3KT0wKRv09B4ATEDUcGHtpbLkmjNfD65boDL99kYE6GzyEdwORI9MlldZKbTx/IbJn+584viYfawue76VO+5ZaOmUZDJsKUmWg4fOpFf1JWGTyk4dMnnyrjJMGJj9dL/8s5ZaqPryPJgM9JT2atTg7H7+dt4w4rEyF5j+wDfpwnYnTeKaki8BG4PGdKMDixSh+Vcsp7uEwm8pVlSSIz6VWORHjmzP83+QcnBakHp+TEFHilbPIabhfS3k1t4zYgP6VeZN/y43xUb6oDiHyQUbaJt4XipWwDh0zyTJ+8XGqH2+3G2LFj7YejzxSDJc7q3WLSuVprEBeWPvl1PKjIDIMHrjMFBSdykHVKh+fkZjJYfj1fyHTKnih4UsCUO2NIXya9kAwmgyIS4lmSbB83BqcdaGQYnHgkTI4jF2VNzsP7UrZZZp9SJk6ypDvZB9Q2E4FzO6F7eBCTdsEzM9kvToFHnqN7uO04XU91nslGpZ3z706BxskvZHLVGhE4BVV53qR7vp7pFKx4nSaSdpqukvrlZO/UJ1w/MrDTfdwueHCXCSGPB1JuajuXg0YPvM+437Y2LSdlN/3Pj/H20P/01gRTgsDbzNtI7eEy8p1wLtepX9f91re+heTkZCxduvSsCOYffuU+Nzb6Ls/LT94ppv9N97YWoPk1kiQIMmMyEQ+/13S/KfPkBMuzLJnhS0iCciqTyuFrXk4ZNQVhrhvuEK0ZGl3rlOXwUZRpBCIDJF0rSVFeZwpenHD5SNOUzLRmFzLrlWTsFHC5XTidl8GmtXu4bXHdmQibrndqp0lO6TumuuU8O/9ffm+N8EwLznxdjJdp8n36JD1IuaQfmuyYt0vWKyGTRNNuTrlOayJSflz+L33V5L88iLdGxHScxxATYcg4ZvINWaY8x9tvmuan8xkZGbjvvvsQDAaxfPnyNpEkcBbkYhLcKXCajFI6Ag9C0oicpsukE0pikhmSk7w8u5X3OjEzD4aUJcjyeSA1jTToGpNeOIkQeFYMnF7odCI+k3PR/fx3dVojcVMmK+UwEZbsF+kQJKMMXHKK0jSNKnV1psBrmirjCYfM7AlOiYs8x/VoCkjS9vi6o7yWPs9k2ya5JEE7BRc+KpZ2K+9zCoBky/w6rl8ps7QJkoPXK32Dy8J9VPqMrIPqlnYnfZrbnfQ7SSQcTv7S2nmZ0FB7Xa7I2QCn8ri+iRRlHXzjgFzHkz4qYyPXGXB65CNHWHR9cnIyLrroIqxatQotLS1GPUmc1YI+/3TKlKQCTN9l5uiUOdC5tgy9TUbDRxEyqLVFXnncZJymjqD6TZDBnTsQ38pN5VFQ5s8iSOeRAU0GIOnIUg8mEqDr5DSSSb+mgEifPPDxPuT1yF2BctTD63YiUNleqRs+4pN9xY85OTwPznIdTAYRJ7LjnybCkW1srT9NtuhESE6+JfXHg7rciSd9lgdjp3ZIPfMyTIQkybK1hEm2WfYHh4wdpkRSJkP8eGvfOdk6TePLRJa3sTVQO3mfOPmuk84JpmRIxi7TbIv0+7PBV54W49mgyRlMHceNjA9RTa8sMC3KS2MzNdiUYcp1AyfSk8dMHUBlktw8YEhSlM7vJCM3GL6zSd7DnYSPREztkEHHFACkPKY2mxxTXiezXbpWbgKRQcOUrZtGhCY5nWCSkf/J509M95uOScelepwya5NMHETaJvJ2CsCA+Ul6fo6uN60ttKY3OXohGU2+4xQYTUFJTjmbdCLti69ftma7Z5Mkcl2YkqrWwO/l9snv5zMKMvYBkeRjsgdZH4+rvFxpEyb9mGKyicRNMcDUbuq75uZm+zmktuCsRi5SUKeG8QBJ/8spqNaUawreTkqTxmYiF35ezsHysjgsK3pLMn2SkfHpBgLJwBfYzgTprDw4cEcnmUm2M219pPZzJzWRhQw+MkjRORP58OtNdVOd3Mn4PZZ16nkn+eoK3k98g0Jb9GlyXtIZEYyJDJ2yUl43l800J25KrEz/c3lkEkV/puegnOSVvkXn5DNTTr5iSlqkfCZZW8tseRtMmTOfriWY/JPLJ8uX7TeNKslPZDJE4Bt7OJz6xWSjpDuTfng9NLXtNAI2JXq8XpMN8aTsTH0syY3LatI3Jzb+7FJbcNbTYjLIJiQk2MLKbJqPbGjKh79yg5djIg65UNha5kXnecdJlufMDyDi6XO635TtyY7l7ZLGII3L5ECyLVQOf0CN/qc35vLX3ZBR07MeVLfJOaTTyGukTrlx8r7hgUbWYQIvh/cvdyr+oCeNKLjMfBrFlJiciWh4/RRgeJ/zOky6kHWY9CLf59WafiWZE+SUk6m+1tony5dTWrLfnEhaBlKnergNStuQbxEGThMc9wOedDpBBjhuA06JjkxmeHtk0OcJG9eL9E0uC5+i5jFCJlDyGTCeiHNS4MQgZZaJsQz+ZM8Ug9uSOHO7kHrjdkHnKf6cKfaacFbkwqeyqHGBQMA2Kjm9JQO0VCJ3bh54+M+RSgM7U0NNWYXJGWRmTIYvs5jWMiYZCLlT81EX1wGXkx+nMohEpMNyZ+D6k0ZkcjbTjhzeVn4Pz8qpz0xPc5scUUKOVnkZsg1UJh/l0nlpI7wdTgRjmoKgH7qiUSVlkk7Bluuag4+AqD0mOzVB2iRviyRTfn1rxMfPyXUtE8GbEiZOfGS7putkfby/TEkU2bRpGteJ1Hn7pY7lyFvaGA/cvGxuz2RzZNu0HifJVdqYTIIlTH3EE21qM+nZ9CyTnOmRupZxQ45YuLyy7Tzx4EkB7wt5H+nqbKbDCGc9LcYdggTlr5bgr56WTscbQAJzJZkCjFM2ZwJXnMnIeGfIzII/yW0K/DI74efkA6VSdrkNl/TBjdk0SqPjsl1cT6bgQ9fxXW3c6KRx8zZzgiPnIwOTRszrlYFKtpP3Mf3Pz3OSkf0u1/akjlpzEB4kZP9TskQEw/VnahvvXwK31TORLV3fWjucdGeCqQ/ok+RqbWQmy+b+7UQCpuRCZrvSlug+JyJ3ko/K4LYnfclEyE7g7eNyy2etpG54XTzZkpm+SZ/yf36dnDrnCXZrSYpp1MHjEE/i+bQo1yfVJRMQSd6cAHmcbwvOeiuyDGL8VdsE0zqAZH86JoML/612GRicsgbpXKTocDhsTx3JACMzFZNscuTFgxN3Xp75yAAhAw/vTF42l11mtKY3QPNRC9cVd3iZHcs6ZUDkeuOZjSRC+jxT2UDkw6Umvci2ymNOGbOpflNA5OVyPfP75e8UEUyJBq+f9CPtT+qKQ+pBOjgPmLItJj1QGRx8MwxPQrieyAdke2Q7TD7S2lZarmuT7TvphZcnSYvLJn2U+6XJXpzsVvqLE+lz2eToh29I4nWZ1pEITomi03dTW0w65Po16VX6nslWTXHB1H9txVk/oS+/y87k02RceJ4lyM4xOaMMajKr4DJwlpaOa8rwZYCXwZM7pdNwFkDUNKBp8ZQvyPOsRbaLyjW1lwdRTmokJ5G7JGBJeASZ0XK9yADAr5HG1dpIgQe81trCdURBRPYP9aWpP7mueV3SrkxE2lrGy/uFBzP6lMGSBzin4Mn1zMt3Csamcpx2lnGd0nWy/U4ykD5koOSySXl5diztwETopmAofdCkJ65vWSZBkp1MXk1lcJiIhWSQ8nG9tLbjT7bTNDXdWuLUGkyyApG/1STjq+yXMz2ILafCm5ubsWHDhlblkmgzuTQ3N9u/Dc0V09pT0LzRdC2d4xkbd1KZRUrj5eVxp6IOlNc77aaSTgNEDgulY/HpIn49yU5Dfj6Py4MTD950D/2gF9/yKcs3kaocNnNSonskcct+kxkSl89pl45T4DQFBpOj8SDAiZjup500slxJTLJOflwSjUkeGSidrpV64jDtzuGjblP2yfUpP+W0ilNgM/mb1LspCXAKtLJNXBZuu1J+ORri5XJ5yR9kOeQr0jd44DP5GZUrZeIB3gmttYMfa00/PHHicvGRoCmB4okh14GTvE7Huc3JNXAeW7lOpc7I/2Q/yaSC31dfX48tW7Y46taENpPL008/je9973vw+Xx2pfTZmuGaMk0Z1LiynIyawImFszT/32TIdA/VY3JC08jDlHGbgmY4HI74tUYuJ1/DkLojxzAZM5e/tW2CXM/UfkkSXFapc95mJ6OWmb7sfy6b1I1ca5FJBnB655gMhFIPJvD6qAyeuctrZALkFEDlOZN+uC27XC578VoGWWmD3G+kH7TWPn5MJgpcn5wkZXJi0i9PFuVozTRNJ0mYly/XJGQ8kCRA18k1GXkvjw28ThmDTO2UeidbJHDSNk2H8tjE9cVJyqRT2W5+bVuJUOqJxzo+7Uz10TS9iSSkXqTu5bonyTx79mw0Nzc7ymtCm8nl7bffhsfjQUFBAUKhEK688kpkZmaeKkS8mVcqSHYUVxZ9SnKgQM1hGrHwUQJ3JO54psBCazH8vClz44xuAs8QZHYl66SpndayVKkbGXRaM2BpvNJJnDIyU508yMupstb+55BTPsDpEZ5TwJVrECQXn8fm7TAFMKrb1Cb635TRtUUnrbVXEg2/1tTfvA1cHk6MpuAsZZDlkZ1JHUrZZDmm/ufHZbBsTW/cd0xEwsuVdZp0J+81lSfLkSNTKYcsw5RImHQmSZw+Se/yOv4rtSa5Te1sDTJe0r3SDpy+S4TDkTvXuM9aloWTJ09+pV+kbDO51NTUYNasWUhPT4fP54NlWejevTsyMzPh8/kiXk8SFxdn74+m3/aOizv142KJiYkRmR01hgdCWkOQU1oyqHAF8I7hQ1VTdtXY2IiWlhY0NzejubnZNgK32w2fzwefz2cTlzQYXi8vE4jcacUNkra/0qjP5HgtLS32tIrH44kwPjl9GAqF0NzcjJaWFvsH1/h7x6iMpKQkpKamGofJnIC4vqQuTSTJdcHP1dfXo6KiAtXV1WhoaLD1TO2k36tPSUlBamoq0tLSkJGRAY/HExFUqT3klNSPoVAIfr8fLS0tdvnNzc32r/G53W54vV4kJyfbZft8vqipiLYQRSAQQE1NDSoqKlBbW4umpibbHhISEmw78Xg8UfZBdp6YmBjx2/a0dZ/+5Eg5Pj4eHo8HKSkp9pQphxPByH6i85R4kW3LEYNT0sJ9TH6Xtk4jdqcXppoCmyyLH5OzCjxJcpLB5XLZz3qY2mZqExA5DUv2w7f9+/1+28/8fn+UHVOMo1hFMY58j8rh8lrWqXXpuro6NDY2Rv2SpExU4+PjbZtOSUmxnxM09Yvf77fL9fv9Eb/qSZ+UqJGcXq8XPp/PLpcngY2NjWhqasKOHTtw5MgRnC1cVmvph0KhUCgUXwFt/pljhUKhUCjaCiUXhUKhUMQcSi4KhUKhiDmUXBQKhUIRcyi5KBQKhSLmUHJRKBQKRcyh5KJQKBSKmEPJRaFQKBQxh5KLQqFQKGIOJReFQqFQxBxKLgqFQqGIOZRcFAqFQhFzKLkoFAqFIuZQclEoFApFzKHkolAoFIqYQ8lFoVAoFDGHkotCoVAoYg4lF4VCoVDEHEouCoVCoYg5lFwUCoVCEXMouSgUCoUi5lByUSgUCkXMoeSiUCgUiphDyUWhUCgUMYeSi0KhUChiDiUXhUKhUMQcSi4KhUKhiDmUXBQKhUIRcyi5KBQKhSLmUHJRKBQKRcyh5KJQKBSKmEPJRaFQKBQxh5KLQqFQKGIOJReFQqFQxBxKLgqFQqGIOZRcFAqFQhFzKLkoFAqFIuZQclEoFApFzKHkolAoFIqYQ8lFoVAoFDGHkotCoVAoYg4lF4VCoVDEHEouCoVCoYg5lFwUCoVCEXMouSgUCoUi5lByUSgUCkXMoeSiUCgUiphDyUWhUCgUMYeSi0KhUChiDiUXhUKhUMQcSi4KhUKhiDmUXBQKhUIRcyi5KBQKhSLmUHJRKBQKRcyh5KJQKBSKmEPJRaFQKBQxh5KLQqFQKGIOJReFQqFQxBxKLgqFQqGIOZRcFAqFQhFzKLkoFAqFIuZQclEoFApFzKHkolAoFIqYQ8lFoVAoFDGHkotCoVAoYg4lF4VCoVDEHEouCoVCoYg5lFwUCoVCEXMouSgUCoUi5lByUSgUCkXMoeSiUCgUiphDyUWhUCgUMYeSi0KhUChiDiUXhUKhUMQcSi4KhUKhiDmUXBQKhUIRcyi5KBQKhSLmUHJRKBQKRcyh5KJQKBSKmEPJRaFQKBQxh5KLQqFQKGIOJReFQqFQxBxKLgqFQqGIOZRcFAqFQhFzKLkoFAqFIuZQclEoFApFzKHkolAoFIqYQ8lFoVAoFDGHkotCoVAoYg4lF4VCoVDEHEouCoVCoYg5lFwUCoVCEXMouSgUCoUi5lByUSgUCkXMoeSiUCgUiphDyUWhUCgUMYeSi0KhUChiDiUXhUKhUMQcSi4KhUKhiDmUXBQKhUIRcyi5KBQKhSLmUHJRKBQKRcyh5KJQKBSKmEPJRaFQKBQxh5KLQqFQKGIOJReFQqFQxBxKLgqFQqGIOZRcFAqFQhFzKLkoFAqFIuZQclEoFApFzKHkolAoFIqYQ8lFoVAoFDGHkotCoVAoYg4lF4VCoVDEHEouCoVCoYg5lFwUCoVCEXMouSgUCoUi5lByUXytmDFjBrp27fp1i6EwoGvXrpgxY8bXLYbi3xRKLv+H8Oqrr8Llctl/8fHx6NSpE2bMmIHS0tKvW7x/OWbMmBGhj7S0NPTv3x+//OUv0dLS8nWL9y/BmjVr8OSTT6K6uvrrFkXxH4b4r1sAxb8eP/7xj1FYWIjm5masXbsWr776KlatWoWtW7fC6/V+3eL9S+HxePDyyy8DAKqrqzFnzhx897vfxfr16/HWW299zdL987FmzRr86Ec/wowZM5CRkRFxbteuXYiL0/xT8dWg5PJ/EBMmTMDgwYMBAN/4xjeQnZ2NX/ziF1iwYAFuvPHGr1m6fy3i4+Nxyy232N/vv/9+DBs2DG+//TZ+9atfoWPHjl+57HA4DL/f/29L2B6P5+sWQfFvDE1LFBg5ciQAYO/evQAAv9+Pxx9/HIMGDUJ6ejqSk5MxcuRIfPTRRxH3HThwAC6XC8899xxefPFFdO/eHR6PB0OGDMH69euj6pk3bx769u0Lr9eLvn374t133zXK09DQgEceeQQFBQXweDwoKirCc889B8uyIq5zuVz45je/idmzZ6N3797w+Xy46KKLsGXLFgDACy+8gB49esDr9WLUqFE4cODAGXURFxeHUaNG2e0DgJaWFjzxxBPo0aMHPB4PCgoK8L3vfS9q6ozkeeONN9CnTx94PB588MEHAIC33noLgwYNQmpqKtLS0nD++efjt7/9rX0vTVl+8sknuOeee5CVlYW0tDTcdtttqKqqipJz0aJFGDlyJJKTk5GamoqrrroK27Zti7pu586duPHGG5GTkwOfz4eioiJ8//vfBwA8+eSTePTRRwEAhYWF9vQgtZuvuWzYsAEulwt/+ctfoupYvHgxXC4X/v73v9vHSktLceedd6J9+/bweDzo06cP/vznP59R/4r/HOjIRWEHk8zMTABAbW0tXn75ZUyfPh133XUX6urq8Kc//Qnjx4/HZ599hgEDBkTc/+abb6Kurg733HMPXC4XnnnmGUyePBn79u1DQkICAGDJkiW4/vrr0bt3bzz99NOoqKjAHXfcgfz8/IiyLMvCtddei48++ggzZ87EgAEDsHjxYjz66KMoLS3Fr3/964jrV65ciQULFuCBBx4AADz99NO4+uqr8b3vfQ9//OMfcf/996OqqgrPPPMM7rzzTixfvvyM+iCSzcrKQjgcxrXXXotVq1bh7rvvRnFxMbZs2YJf//rX2L17N+bNmxdx7/LlyzFr1ix885vfRHZ2Nrp27YqlS5di+vTpGDt2LH7xi18AAHbs2IHVq1fj4Ycfjrj/m9/8JjIyMvDkk09i165deP7553Hw4EF8/PHHcLlcAIDXXnsNt99+O8aPH49f/OIXaGxsxPPPP48RI0bgiy++sDdIbN68GSNHjkRCQgLuvvtudO3aFXv37sXChQvx05/+FJMnT8bu3bvxt7/9Db/+9a+RnZ0NAMjJyYnSyeDBg9GtWzfMmjULt99+e8S5t99+G5mZmRg/fjwA4MSJE7jwwgttss3JycGiRYswc+ZM1NbW4lvf+tYZ+0DxHwBL8X8Gr7zyigXAWrZsmVVWVmYdPnzYeuedd6ycnBzL4/FYhw8ftizLsoLBoNXS0hJxb1VVldW+fXvrzjvvtI/t37/fAmBlZWVZlZWV9vH58+dbAKyFCxfaxwYMGGB16NDBqq6uto8tWbLEAmB16dLFPjZv3jwLgPXUU09F1H/DDTdYLpfL2rNnj30MgOXxeKz9+/fbx1544QULgJWXl2fV1tbaxx977DELQMS1t99+u5WcnGyVlZVZZWVl1p49e6yf/exnlsvlsvr162dZlmW99tprVlxcnLVy5coIef73f//XAmCtXr06Qp64uDhr27ZtEdc+/PDDVlpamhUMBi0nUN8MGjTI8vv99vFnnnnGAmDNnz/fsizLqqurszIyMqy77ror4v7jx49b6enpEccvueQSKzU11Tp48GDEteFw2P7/2WefjdILoUuXLtbtt99uf3/ssceshISEiL5uaWmxMjIyIuxi5syZVocOHazy8vKI8qZNm2alp6dbjY2NjnpQ/OdAp8X+D+Kyyy5DTk4OCgoKcMMNNyA5ORkLFiywRxFutxuJiYkATq0bVFZWIhgMYvDgwdi4cWNUeVOnTrVHPcDpabZ9+/YBAI4dO4ZNmzbh9ttvR3p6un3duHHj0Lt374iy3n//fbjdbjz00EMRxx955BFYloVFixZFHB87dmzEVuZhw4YBAK6//nqkpqZGHSeZCA0NDcjJyUFOTg569OiB//f//h8uuugie8pu9uzZKC4uRq9evVBeXm7/jRkzBgCipgovvfTSqDZlZGSgoaEBS5cujdKdxN13322P9gDgvvvuQ3x8PN5//30AwNKlS1FdXY3p06dHyON2uzFs2DBbnrKyMnzyySe488470blz54g6aAR0tpg6dSoCgQDmzp1rH1uyZAmqq6sxdepUAKdGnnPmzME111wDy7IiZBw/fjxqamqMNqT4z4NOi/0fxB/+8Af07NkTNTU1+POf/4xPPvkkavH2L3/5C375y19i586dCAQC9vHCwsKo8mTwIqKhtYKDBw8CAM4777yoe4uKiiKCzcGDB9GxY8cIYgCA4uLiiLKc6ibyKigoMB6X6xderxcLFy4EcGoBu7CwMGKqrqSkBDt27DBOFQHAyZMnI76b9HP//fdj1qxZmDBhAjp16oTLL78cN954I6644oqoa6WOUlJS0KFDB3vqsqSkBABscpNIS0sDcJpE+/bta7zuq6B///7o1asX3n77bcycORPAqSmx7OxsW56ysjJUV1fjxRdfxIsvvmgsR+pM8Z8JJZf/gxg6dKi9W2zixIkYMWIEbrrpJuzatQspKSl4/fXXMWPGDEycOBGPPvoocnNz4Xa78fTTT9vrERxut9tYjyUW4P8ZcKq7rTK53W5cdtlljuWHw2Gcf/75+NWvfmU8L0nM5/NFXZObm4tNmzZh8eLFWLRoERYtWoRXXnkFt912m3GBvDWEw2EAp9Zd8vLyos7Hx/9zXXrq1Kn46U9/ivLycqSmpmLBggWYPn26XS/Jd8stt0StzRD69ev3T5VRcW5AyeX/OIg0Ro8ejf/5n//Bf//3f+Odd95Bt27dMHfu3IgplCeeeOIr1dGlSxcAp7Nujl27dkVdu2zZMtTV1UWMXnbu3BlR1r8K3bt3x5dffomxY8d+5ekkAEhMTMQ111yDa665BuFwGPfffz9eeOEF/PCHP0SPHj3s60pKSjB69Gj7e319PY4dO4Yrr7zSlgc4RVitkWK3bt0AAFu3bm1VrrNt09SpU/GjH/0Ic+bMQfv27VFbW4tp06bZ53NycpCamopQKNSqfIr/fOiaiwKjRo3C0KFD8Zvf/AbNzc121s+z/HXr1uHTTz/9SuV36NABAwYMwF/+8hfU1NTYx5cuXYrt27dHXHvllVciFArhf/7nfyKO//rXv4bL5cKECRO+kgxfFTfeeCNKS0vx0ksvRZ1rampCQ0PDGcuoqKiI+B4XF2dn73I784svvhgxDfn8888jGAza7R4/fjzS0tLws5/9LOI6QllZGYBTQf6SSy7Bn//8Zxw6dCjiGt6vycnJANDmJ/SLi4tx/vnn4+2338bbb7+NDh064JJLLrHPu91uXH/99ZgzZ46R2Eg+xX8+dOSiAAA8+uijmDJlCl599VVcffXVmDt3LiZNmoSrrroK+/fvx//+7/+id+/eqK+v/0rlP/3007jqqqswYsQI3HnnnaisrMTvf/979OnTJ6LMa665BqNHj8b3v/99HDhwAP3798eSJUswf/58fOtb37Iz938Vbr31VsyaNQv33nsvPvroIwwfPhyhUAg7d+7ErFmzsHjxYnuK0Qnf+MY3UFlZiTFjxiA/Px8HDx7E73//ewwYMMBeSyL4/X6MHTsWN954I3bt2oU//vGPGDFiBK699loAp9ZUnn/+edx666244IILMG3aNOTk5ODQoUN47733MHz4cJuYf/e732HEiBG44IILcPfdd6OwsBAHDhzAe++9h02bNgEABg0aBAD4/ve/j2nTpiEhIQHXXHONTTomTJ06FY8//ji8Xi9mzpwZ9RT/z3/+c3z00UcYNmwY7rrrLvTu3RuVlZXYuHEjli1bhsrKyrPqA8W/Kb7GnWqKfzFou+v69eujzoVCIat79+5W9+7drWAwaP3sZz+zunTpYnk8HmvgwIHW3//+d+v222+P2DZMW5GfffbZqPIAWE888UTEsTlz5ljFxcWWx+Oxevfubc2dOzeqTMs6td3229/+ttWxY0crISHBOu+886xnn302Ygst1fHAAw9EHHOS6aOPPrIAWLNnz7aP0VbkM8Hv91u/+MUvrD59+lgej8fKzMy0Bg0aZP3oRz+yampqWpXHsizrnXfesS6//HIrNzfXSkxMtDp37mzdc8891rFjx+xrqG9WrFhh3X333VZmZqaVkpJi3XzzzVZFRUVUmR999JE1fvx4Kz093fJ6vVb37t2tGTNmWBs2bIi4buvWrdakSZOsjIwMy+v1WkVFRdYPf/jDiGt+8pOfWJ06dbLi4uIitiXLrciEkpISC4AFwFq1apVRZydOnLAeeOABq6CgwEpISLDy8vKssWPHWi+++KKjnhX/WXBZ1r9g1VWhULSKV199FXfccQfWr19/xpGQQvHvAF1zUSgUCkXMoeSiUCgUiphDyUWhUCgUMYeuuSgUCoUi5tCRi0KhUChiDiUXhUKhUMQcSi4KhUKhiDna/IT+P/JeJYVCoVD856AtS/X6+hfFvyVaS3ZM59pyrLXvpv+dzp/pmjN9fpVz9Of03XSv0z3yWFvrcOqTtu4Zaq2P2tJ+p/a1Jqfpmri4OOP9/C8uLi7itTf0ne7ln7w8t9sd8Z3udbvdETLy++Q1VK+sg5ftdrsRHx8fVQaXX8ricrmQkJBg1+NyuewyuAz0M+JnwjlDLj6fL+odRSacTZA4W8c+W6f6R/9kx5q+A9GGK43PZMitHePHnQyurX/yPnk/fQ+Hw7AsC6FQyDH40adlWVFBgI7RdZZlIRwO2zqSfW1ZVoQ9UYDjegiFQhH6pTrpXtkH/DiXj45blmXXI++zLAtut9t+KSgd544s5eT9FA6HEQqF7KBBZZoCCdUTHx9vlxsOhyPaQ4HD7Xbb8tN9MsgBiDgXDoft+qSdcSIhHQeDQbv/ef/IP0IoFIqyASqbXulPkH1M7eRt4v1K9VAdMuZQvfyT9wc/x/uW2zzJIP9Ij1yWYDAY0Q5qH9VBepMxjtpKdVFfc3mob8nOqS38U+qF7FPaI+kLgP37R2fCOUEuLpcLL730kv1a8a+j/lhe29bynEiROxoPTE7Xt7VuaVxk9OFwGIFAICJwUWDgzsevl85guo5ADhcMBm1DJ8On8xSkuHPw9vNyqF6Sj9/LgynJwh2W6qY2cwLkgY7/LookEd42HjTpXiJQk544MUhS4n+SWC3LsvuIt4XK5cGfCEYSkwwmPECa7IbrmvRE3022yPuKJwCyTTxIkz3Icjmxcb1ykuTl8OtknZx0eRkmPfM+5WRJPsgJjvTCZZBtl6MSLpckKNnfpmMcXNcSpC8TIXP/lgkdT/5MbSstLcWKFSui6jPhnCAXy7Lw0Ucf4eabb/5a6j5TQD4b8mlrnSY4kQs/J689mzqcjJacQAZpmTlyIpEZH88seRDmASMuLs42eOlkJsIzOawMIMFgEG63GwkJCRHXOAVA3mbePvqfBzuZvUq98szRFDxl++l6Dgp2vGx+vWwPv5+TMAUFIkVTIsHbxstwCrL8PC+HyNmU+Uod837kOpdkSnqQIxGTT3A9mwJua8FanpeJjKxLtknqyCSzkw65zNxuOPGb2upEgADsJELeJ/3HJJNpNMR9V/okcOoXTk2/y2TCOUEuwKmfr5UdxWFygFgE/TOVEWti4WhLG2SAk5lGWyBHIFQOH+qapjR41s1JgZdF98mgbGoHBUCTEUtnN11DwUqOkkKhEBITEyMyymAwGDFdwHXGA6MTCXHndyJ4arM8zqfQJJHKYMYzaV6OJF1ep8zoeaYZHx8fRWCc1Lie5eiA10t9LomArjlTAuQUKGVfyz8+4uSfoVAoSt/SN0ykwHXEyY4nKLwdrREIPyenY8/UXirDRLiyPm47dI1JTm4zJr1K8H4y2aapHNI9/f/6668bkxQTzhly2bdvH3bs2IE+ffoYz5uyw/8EtEYSpiDolGG2Vj6V5UTcremSZ9H8GM9epZPz+qQR8/MyA6X5eRqF8MDHiYPLQQGQz13z+WZpMzII8CDDz9P6Bl1jIhY+rcDBR2h0PycFHrh5+039wUd91EYOyzq9lsN/2pmXTwRmylz5FB4POnLdgLfBKRDJdRW5zsavk4Ge2sgDsbxHBj1ZP+8/OQqXI0h5v4S0T7kOxHUtEwE5VRwOhyOm1JxIwBTY+TkZA/johSdgJkg98T7ibZR18z46duwYNm/ebCzfhHOGXI4cOYK9e/c6kgvwn0MoBNOwVIKck66XUwtOOpFZlswOnUhaBj1eHjkJEOmg/H856pAy0jkKeLQwzEdHwWAwYs2DO6ScB6djdK9ca5D6MrWVRjqm6QWuN07OPKuXi8g8qPKFfe7AMmM1BRy5HsGnxngQB06vuTj1i8zgeTtl8HVKYGR7+RSoDJqmenhdfDTlNMUm+1hm2Fxm3kZeP8kn7YaIlJIE+l/aihw1A4iYepRrP5wcZf/KxKY1kpM6k3JJHXES4LKbbJTbHvd33g9SPgBYsWIFSktL0VacM+Ti9/vPODX2fwkyW5drGKbpHBOcsjU5sqBzvG6eJXED5+UFg8Eox5FkZlqjAU4Pt+Pj4yOyYgr0fNGfZ38m55HBmTubKWhwvZqyOjrPs1Ue7KVD8rUPng2akgATOchsnU+X8XbxbJh0wkctPHBKwjAFTRnUZT/zgCTPyyDuFGzPFBy5TqUNEpyCrykw82ucypBkQHYsN3dw2aVOTMRmkoH6S17L7U+OOJzqMtmWiVhke6Xf0D1yhMrrJH8LBoNoaWnBkiVLjD+t7YRzhlwAYN68ebjnnnuQmJj4dYvyT4WJFEzOI4evpgAh7zeNhqThtXZM/i8zb5OsvF0kN2XRpikCOUURCATstpk2FtCohtdhaiMnHyeHl4Gelymdkerm8+sy4BNkcOBE4NQfUmdOZCmDAQ/0RCw8YPEyTO3lZfIRBrWDJwgkI2XrvHx+PW8DBSRa93IiBtm3ACLukXqQ9/NruM3IzSdA5LoBbzMfRUldyO+cwDkpc53JoC/llXYg1y9M13Lf5/ZoSg44OBHR9Vw3XEZuf6bNOSdPnsTatWtxNjinyGXXrl0IBoPnNLlIZzU571e5XwYsHnRkoGktuEkC4sGIg67hU0O8vtYIUMrFz3PDlbK2lsnTd77PXo4U5KhN6kEGU+l8/JipH6TO+LMDoVAICQkJABAVEKTzOpG4Ux0AIgIGD9hS93z6UI5Y+LnWEgHe37w9TnZlWVbExgiXy2Vn+rydfMeXzIx5WXK6j+vNRLB0ndwAIm3UaWqPjtNWZD6S5aRDbSGCkwTrNCKTfiHbZupfOQVlskeuWzmylbqT/cZ926QLKRdPBGU5LpcLCxYsQENDA84G59T8U319PbZs2WJkYROkw8pjZ1tGW+5zyqraUhfdf6by6LgpEJvq5QZLAUYOleV9wOlAxeuTIyP5XAA5p9xDL4ObnIM3OR6XgQcoGnqbFpe5HvinPMbr53qRwVuOSrhOZACQzwDQIjtvu8yQeXtNeqCyeJDhDx7ywMzbKZMJWQe/jgczeQ3JzTcLSPuh0aXf7zdOp/A+lv0p7UBuRZfTRbL/5P9St0QaEiYdyzKkLCad8Qdtef/JtvC+kDqRI1jZf/xTPs8mZTMldRJylCvhpEduR7zfampq8OmnnxrLag3n1Milvr4eH374IYYOHRqzMk2O/lWuMd1jMpyvCjIcmVWQ0/PhMK+fGwc/xjN8Wqw0XUcwTSVIhyO0ljGanlMwEaLTqMMU2KQDkixyxw7VzwOGyVE5WfCpDFOfyMAhZZKBT05byLUTKkNuOOC6MOlRJh78qXxJovS/0/SJbC8fafBMlo8mJEHwfuWZPidpSZhc95y4uV55G022YZLfNP1E8vBrOFEFAoEoguS6k0HXNJqittL/pq313BclkUlIonVKFmgUKUmM6qH+4bMA0j45QfIEyyT/vn378Pnnnxtlbg3nFLmEQiEcP34c4XDYmI1ISOV+VbQ2tG1L3WdDSm0pj4MHfXpCW26z5YbGA6YkH56NOA2VZQAmYqIAQuDlyKBoCgwyW+PkLEmV2srl5K8e4e3hUx68PtlGWQd3skAggISEBOPmBtP//I/vMjJNW5g2AXB55HZmvuYkRx08aLhcroiddlIuU8DmwYs2TNB3HmBNSQ4H7wP+GhVTcJWQgZOPTnkyZNIh6YT3k0kmmeyYEpczQeqa60Has9xCLdtvIls6z7f/8j4zzQgEAgFYloXk5GRj0sT1KpMZPqMhp1PlFnMOl8uFZcuWobGx8Yw6kzinyAU4td3t5MmT6NChQ6vX/SNk0pYy20IaMhtsrTynss5UJ19Q54FCGrEM1vxeqp+CgVOw4P/zcmRQl7LzQCRJgv8vs1e5CMuDGZ+OACL38tO18tkRSbh03DTy4ffxp5x5GyQRcefl/WUiJKkHk874yJQHTmkD8gFW2QemaS+Z/MikQWbtppGMU4LH9UF9YMrKeV9IvfE2h8PhCD3weiRBm16lInUu22RZlj3NyOWS4HYppx1NCZATmUu/lPeRH3IdW9bpDSm8LZZ1apTV3NyM/fv3IykpCd26dYvaci/rljbOt1zTMfqkzTdyKzsA1NbWYsmSJUY7OBPOqTUX4NSifm1tbZuvPxPJnOk8GVRDQwPKysocy5DOU1VVhfnz52PPnj2O17flmBOkkXJ5TU7MP53uNZERP8cDjsmpyCGcsjCZaUvdcdlMbSVwQuVbQ/l18h6+BVjOOZPstD7Cz1FQI+fjbWutfVxnvB0y0Ms/2XaeDcvMleuczkvy4G3ibZPBVPYzr9O0qOu0MUHK5UR0piSEX8PLlkGRdprxPuXX8r6S9iWJjq9fyXbwcnnyxQnT9AYFrjdOBtw3eZ9TmdQmvi7HryE5+SgjHA7D7/dj7969+OKLL5CRkYHExMSI9vH75XqhLJvLJtcgeZ10z8qVK3H48GF8FZxz5NLS0oJdu3ZFHDMFd3leOr48FwwG4ff70dDQgPr6+qgAfPToUXz88cfw+/1R9cr/Q6EQ5s2bhx/84Ad4/vnnUVdXZ1/TVrSFWGTWxo2XP3DIjdG00C71Jo1XBjQpIw9mVL5czDxTu7gD87q4k8kFVtOIg7fJND3C6zO1U25goFGS/OMySNlMWbjsF94PvG/4n7RV3k7THw+AJtuUfiBl5Jm5zGoluZlswLQeJuXl5/j1MmhJXcvALJMFHjTln+x37vM0lcTbzh+ClIkCt1Oqz0QWsq0mHZgSBpNeyJZJZmkn+/fvxx//+EdkZGQgMzMzSmaZRFBfBQIBBAKBiJ19VD4ROP3xtpLcgUAAa9as+UpTYsA5SC4AMHfu3FbPOxGMDKT8kx4EWr58OR577DGUlpZGXOv1evHll1/ax1uru7a2FuvWrcM999yD2tpaHDlyJOIa05BbOoEJPDPibZJl8kDG7+X3mZxABkfeTlPQ54bLMzMuJ3d8uQjNg4mTTmUWRXXxdQdu8DQPbnqmRQYkSUb8f14XDybUDtMUhZM+ZZtNdkj/y6zbqX94oJM2QokSJRakXz5akbbE2yY3MchrZN0muZwIzZR50/8UyKg+mcxIXfF+5H/Snpz8RpKkU79IOzbJwm05EAhEBGgK4LI+kw2a6pY+TomEZVnw+/1Ys2YNQqEQhg0bBrfbbZMG1x9PnmQfcZsgO+H+BiBi1EPl1dTUYPHixfiqOCfJ5cCBA8b3KJnAM1CCqSPD4TAqKyvxwgsvYNasWVixYkVEx6elpaGiosI4zUX10LUtLS2oqqrCkCFDkJmZiaNHj551G53WaLiBcvlM5GIyZtl+buDSgUwOIYfK8hoqh2fTzc3N8Pv9UQ+scdKgoCrbRv87Zc28D2W2zwO0adRBeuaBjTuWDJi8X0jnpqyUsky5hiRHZq0Feh4UTJm4JB/SK+mKZ7rhcNgOOHyBmMBthxPlmaadTCMPU+CiT9Ivl1n2Ba9b2olTYJT/c1mlr8tyedlEBH6/30hgvCxpq7wcpyTA5HOm4C7Jl3/neggEAti5cyfWrVuHCRMmICMjA5YV/RYBGqXwvjCtp/Ek0JQgyhH7qlWrUFlZia+Kc25BHwAOHz6MkpISFBcX28dMWRyHXAgk56MODQQC+PDDDxEXF4e+ffti+/btEQtcdH9dXV2UM/BRQTgcRlVVFdxuN7p3746+ffti3759CIVCUVtjuQG3dcsy71z6bsrwuMzcYeWOFlk/N/p9+/ahqakJ/fr1iyrL7/cjPj7efssun4KSGd4HH3yAjIwMjB07NiKAmObyefCla0wPgXFZpW5MwYvXYfrdDalX7ohUjpwu4vdxHXKiowfzuPz8U2ajpm3ectpPTqVQ+dQuuU5Coxlu76YRGZUvkwAaqZnWT2SbZL/wgGy6VraV38uDHp+u5Drhtsb7MBw+vSVXJlVcRi4bn1Y0jdzkJ/Uv3S9jhSSU1jY2yO9y7ZSmZ3ndzc3NWLlyJerq6uxRi/RF0hG3dYLckMGJh7eD2w3pOxQKYeXKlW1O8k04J0cuhw8fxs6dOyOOtUYs/BqTY4bDYezfvx+zZ8/Gddddh6KiIpSXl0dlnbm5uSgvL7eNz7JODyH5CKmpqQk+nw+BQAA9evTAvn370NLS0qa2mYzPdNxEMDz4cPLi302jA7nfPRwOo66uDs8++yy+853v4NixYwBOZzTBYBALFizAvn37IuTjcpJu/X4/ysrKIkiZzjtlsabslDuW1IXMBKV+ZCCR5fG2y+2y9N0pK3XqH9NIkveFKZkwJQom8uLgI0RTIOWJBZ9O5IGOB1XT6IDLzdvGy+cB0ZTpS3uVa12yLt5PvH3yXt5/hLq6OsyaNQv79++PqIOPUPiGAJNfydGc7CfZP1QPnzLlOpHrJLxc7itOu+L4CJ9GLUeOHMGqVatw6aWXIjc3N2qbPx9xNDc34/jx49i3b5+9bmwahfL28TZQYkXH9uzZc9ave5E4J8klEAjYz7twyIAswXcZEYLBIBoaGjBnzhwUFxfj8ssvR1FREdasWYOVK1fahpCQkIDy8nLs2bMnwpnoN6Wpfss6tc+8oaEBwWAQ7du3x9GjRyM2ArQGpyyJZ5qmaQxevwxwJqc1BXK6JhgMYvfu3Thw4AC8Xi+OHTsWYYRNTU34+OOPUV1dbQzwXL6amhp89tln9tBcDu9NJMoXEE07uPioQgZkckCn4MBHRiYSN03dANGvweB1yyDHyzZNLckM1mS3PLjW1tZGvQBUysL1KYOWnIKRbaBrJWlwMnIiU7nd1ak9XF5Tn/M+pikcOsfBRywmecLhMD777DO88sorOHr0aIRswWAQ5eXlOH78eERZXD5qk+m4JGM5feSUCPCdZaa1Jt4H5CPSp0lemvIKBAJYv349gsEgxowZA4/HY5ypIH8tKSnBb3/7W2zfvh0u1+lnoGR/S52YjlmWhS1btjjunm0rzklyAYA5c+ZEPUjnBO5UPAOi4yUlJWhqasItt9yCpKQkhEIhHDp0CCdOnIhwcsuycOLEiQhHlPWEQiG0tLSgrq4OdXV1Nvk0Nze3qV2muU0eQGXmIw2dO7CJXHjwo6kOmUUGg0GsWrUKvXr1Qn5+PqqrqyPmqVtaWhAXF4fGxkZHMqPy6uvrsW/fPqSlpUVMRZoyWy4Hd7KWlhab2E+ePIlQKIT6+vqIUaRpRMozdr7Iz9ti0g3PavlIj295llNdrU2hyAVS7sjSsbldhUIhVFRUYPny5WhqarLrlEkVby/Xv5TFFLRk1soze1mH7C9ZTzAYRHNzMxobG9HS0mIkNW4vdJzAy+SjDBPBmOzGsixUVFRgwYIFSE1NRYcOHexzwWAQtbW1mDVrFubMmRMlBy9b2rGJNPl1PNHgvivBCYXLzGMTt30+lclHpeFwGIcPH8bChQsxcuRIdOjQwR41yUQqGAyiuroa8+fPh8vlwrBhw+DxeCL0zW3Y9JwU1znp8t1333VMItqKc3LNBYC9JgJED1NNgZ9+7lYaOt0zbdo09OzZ0yYGj8eDHj16RDw4lJ+fj61bt0ZtX6QympqasHr1anTu3Bm5ubk4fPgw+vTpA7/fj/LycuTl5bWpbWRQ8gFA2S7TVlsZ7Oj/M5GNnD6ora3FoEGDsGLFCiQmJkY4NACkpqaisrIyYl1EkqLL5bI3M6SlpUWNsrjj0DHq06amJhw9ehT79+/Hl19+idraWni9XhQWFuK6667DkiVL0NLSgunTp0f8uiJflAwEAhFv6+X1cn2Zgj2BrzuQzpzul4GX9yeVIR/ykwRHx6m8w4cPY/Hixbj00ksjrueBhv+GjtN0G/8MBoNoampCSkqK/bJN3l7qT+4zvK0yyFrWqV1LR44cwYYNG3D48GEUFBRgyJAh6NixY1QfS7mknqQupZ1QvXK9xeVyoaqqCrt378bYsWORl5dnJ6B+vx+bNm3Cpk2bcNddd9m2Jh/OdRqJyE/Sv2kNkyd/8g0D/HrZl7wt/MfteDJGxPTll1/i5MmTuOiii5CYmBi1zknXtrS04JNPPsHatWvxyCOP2Iv+XCaSy7S+yUmFsG3bNuzfvx//KM5ZcmloaMDmzZsxbNgwAOZ5QiBy7z4/T9dUV1ejsrISF1xwge34lZWVyMzMRGpqqn1PfHy87USmkYtlWSgvL8fzzz+PRx55BDk5Odi7dy8GDBiAlpYWY2Dn9xLkk/YyQ+SBUF5H5dL1psVhMiZqj2yDZVlobm5GWVkZ8vPzEQqF0KVLF/samgrMyclBWVmZ0fn41MXatWsRHx+Pjh07RrSNFrrpvpMnT2Lbtm0IBAI4cOAA9u7di4qKCng8HnTv3h3XXHMNevToYTvexx9/jMsuu8x2Xu6A9fX1qK6uRlZWVtQaCvWdtBM5DWMidH6viUxkQKTy+LMJwWAQKSkp8Hq9UfXyNlD5gUAAdXV1dkZLNsozepnV8jKonylTbmxsxMqVK7Fjxw5MnToVnTt3jtKHDKoyGMlrmpqasHHjRsyZMwfdu3fHgAEDkJSUZMtMvxzK7Zhk5vrkNi7t17KifzKB2yTJtmPHDlRWViIlJSXi+pqaGsyfPx/XXnstzj///IiRAvcb3ueyHulrkvh4YkPlyZEvB08seKIsN4bwc8FgEHV1dVi3bh369++Pbt262dfJpCUUOvW6rPnz52Pw4MHo16+f8WcBpN1zvXL/oDatW7cOVVVVUXo5W5zT5PLhhx9i2LBhEQrhgZ9/8rlXgmVZSExMRFJSkv0b66FQyJ7Ooikymiaor69HKBSKyOYIdDwcPrWl2efz4ciRI6ipqYHb7UZycnIUAchg57STKxAIRGRA/H8qTzq8DFr0Pz/ONybwxXrLstDY2IjPPvsMVVVVSE5OjnBGt9uN9PR0nDx5MuoNxRyBQAAVFRXo1q0bsrKyIqa9uMwulwvHjh3D7NmzERcXh5ycHAwdOhRFRUVYu3YtDh06hIyMDLRr1w7hcBgHDx5EbW0tiouLI3RIn9u2bcO8efNwxx13oLCwMELHErIf5DE+KjNNfZnuofPNzc2oqanBzp078fnnn6OiogJ1dXXIy8tD3759MXToUOTk5Njz5XzNhORpaGiwN0PwERBvC+mV7I8CEo2UaIut2+1GaWkp3nzzTdxwww0RWSxf8KcyZAJFx6l+8os1a9Zg1qxZuPrqqzFq1CgkJSVF6VRm6SbCkmtw0q+l7uW1R44cwaJFi+ByuXDo0CE0NDTYPrxjxw6cPHkS/fr1i0isqH6+fdc0uuA+wkmYbN80spVTnZLIuK3QOdoyHh8fj4SEBDQ3N2PHjh3YsmUL8vLykJycbG9BvvHGG5GammqXRSNNsofm5masWLECfr8fEydORG1tLUpLS9G5c2ekpKTY9iHbymWnRJRkrqurw5IlS4y+dLY4Z8klFArhyJEjttNwpZgWTLmyuGJSUlIwZMiQiOmv+Ph4pKamYteuXfjiiy+wd+9exMXFYe/evaipqUF9fb3dqbRQTcaQmJiIQCCArl27YsmSJaivr0dKSkqE7JLgeEChNtC5UCiEmpoapKamorm5Gdu2bUNRUREyMjKi5llle3kdpgydT4FwHcXFxSElJQWrV6/GhAkTkJCQEDFH7HK5kJSUhKNHj6K5udmelpIBpb6+Hrt378bEiRORkJAQsTgv1wd69+6Np59+2pYhISEBBw4cwKJFi3Dvvffaoyiabz5x4gRSUlIipuLIwbt27RqRJcqhvykjld95eziBkn3wMuQoxuVywe/3Y926dXjppZfQpUsXdOjQAe+99x4effRRJCYmYtWqVXj99dcxfvx4zJgxAwkJCVHBJxQKoaGhAe3atXOcSgOArVu3YvHixfjGN76BtLS0iD6XRHjkyBGcOHEC3bt3h8fjQUNDA1paWuDz+ezpT25LBNPUTDAYRElJCRYuXIhJkyZhxIgRiI+Pt/uZSFlO+wCnM3UevHkWz+WXAVhOkRGZfvrppzh27BimTp2KTZs2oaqqCh6PB0ePHsXixYsxadIkO8kxzWRI2eRxmdxJn6Jr+Lqp2+221zhIhyYSpbXao0ePYtWqVQiFQpg4cSI+++wzzJkzx05QA4EADh48iGAwiF69etmy8mSC5CsvL8fq1auRkZGB9evXY+vWraiursbMmTMxbNgwu3+kzZOs9MnJ88CBAygpKYnqz6+Cc5ZcAGDt2rU4ceJExEsseeBymnqS01p8VFNbW4uSkhKUlJTgl7/8pR3Iu3btiuTkZJSWlqKlpcU2hk8//RQrV67E3XffjUAggPr6elRUVKBLly6orq7GoUOHEAqFkJSUZMvB51Obmpqwbds2dOzYMWJ+mg+zExISUFdXhw8++AAHDhxA9+7dEQwGbdKhaQdT+6ldlKHQInFLSwvi4+ORk5ODhIQEWz9ut9sOdDU1Nejfv3/EWhUtptPL8sj4qG4eEJqbmxEIBJCTk2P/mqTMPHnA8Pl8AGA/0Xz06FGkpKSgsLAQbrfb3s5dVVUFl8tljwRyc3ORlpZm92t2djauu+46ezrK9FCYJB85CqHMXV5L13PIdtDod+XKlbjpppswZMgQHDlyBAsWLMAll1yCDh064KqrrsL27dvxu9/9Dt26dcOoUaMi9GJZp6bEUlJS0KlTp4gsnxIhnkV/8cUXePfddzFlyhQkJyfbMvv9flsH4XAYpaWl6NOnDzIyMrBkyRLMnz8fVVVV+Na3voUhQ4a0ukWa1hrpe11dHebMmYMBAwbgwgsvtO2L25wkAjlikHqVwZyOyylDaUNlZWVYsmQJLrzwQlx00UVYt24dqqur0bFjR6xfvx4ejwcjR460yS8YDGLfvn3Yt28fhgwZguzs7AjSoU0rPJEIBoMRU3wkGx/RkJ7Ky8uxbt06fPrpp+jbty8mT56M9PR0NDU12e/+InsJBAL2a63+8pe/YNOmTbj66qthWRbKyspwwQUXYNSoUUhLS0NNTQ2eeeYZnDx5EgcPHkTXrl1RVlaG0tJSNDU14bzzzkPXrl0BnEo6du/ejaSkJHtzQ2pqKgoKCqL6xESkwOnYSH8LFiw4q58ybg3nNLls374dlZWVyMvLa3Xxm7IonjWQg5oy2KSkJAwfPhyPPfYYioqK4PV67SBaXV2N1NRU2xh+9atfISUlBcFg0F7o2rFjB4YOHYpAIIC33noL3bp1Q7t27QBEPhBmWRZOnjyJ7373uxg3bhz+67/+Cx6Px5aLAhxNsc2fPx+33XYbUlNTsXPnTrz++usYM2YMxowZE0EeNTU1CIVCKC0txaZNmzB48GD06tULALBmzRq888478Pl8aG5uxnXXXYexY8dGZGPx8fHIzs5Ghw4d0LNnT9txyCFnz56N1atXIzs72w44QOS2aBp95OfnIysry24vfzU/H03S9dTmQCCA7du3IzEx0dYdcCpY7t69G8ePH8evf/1rpKWlIT09HXfffbedZITDYfTt2zeqfEl+fHrRNOKT8+ZkN3xunQc4ObVVWFiI4uJieDwe7N+/Hz169EBaWhrcbjeSkpIwcOBAtGvXDgcOHIiwRcs6tTmksbHRfkaoqqoKqamp8Pl8Ec9WxcXFoaioCC+88AJOnjxpL9QDiNjxRbpfvHgxOnXqhL/97W8oKytDcXExli9fHvFLkpzE+GiCjxIDgQAWLlyIEydO2AvktCOSyqKpYg4iHzkqIRlN5MHJmx+nPqJF64aGBowfP94eKVRWVqKqqgoffPABpkyZgrS0NDspWrNmDV566SU0NDTgD3/4A7Kzs+220wsZjx8/jmuuuQYulws7d+7EJ598goKCAlx99dX2lFVNTQ0yMzPtKcZw+NS61osvvoiWlhZkZWXhT3/6k/3GjiVLluC6665D//790dTUhHD41KL7wYMH8fzzz2Pz5s3o0qULrr76aqSnp2PUqFHYu3cvUlJS0L59ezspvP7665GYmIj58+dj1apVKCgoQHJyMtauXYt7770XPp8P69evR0pKCmbOnInk5GTMmzcPU6dORfv27SO2R8uEj9rBidSyTu2U3bRpE2KFc5pc/H4/Dh48aAdOnqFyR+HzoaYFYB404uPj0djYiCFDhqB///72ToxwOIz09HQcP34cx44dw5EjR/D73/8eLpcLTzzxBEKhEBYsWIBrr70WH3/8MW699VZ07tzZfoElcDojLi8vx9///nf0798fxcXFGDJkCCorK6M6lw+jV6xYAZ/Ph0GDBqG8vByvvfYavF6vXU52djYs69RWzKeeegrNzc0oKipCIBDA7373Ozz11FPIyMjA559/jvbt2+OWW27BsmXLsGrVKowZMyZquiMpKQlerxc+n8/WU01NDV544QVUVVVhwIABWL16NWpra5Genh6RuRG8Xi+6dOmCxsZGuy00LyyzPzpGw/pQKIRt27YhLy/PDhbhcBi1tbXYtm0b8vPzMWPGDHTo0AEvv/wyvvzyS3i9XuzcuRPnnXeevfWZ9Hno0CH7ieIJEybYO/dM0x4A8OWXXyI1NRVdunSxiYi2dR47dsweycokhcjT6/Wif//+aGxsREZGBo4ePYr8/Hx7VGFZlv2cQs+ePXH06FHk5ubC7XZj7969+Pvf/46mpiZs2bLFXnMaNmwY+vXrh127dmHz5s1obGzE2LFj0bNnTyQnJ9sZaygUwsaNGxEOh9GuXTt06dIFbrcbFRUV2Lt3L2prazF06FAMHjwYr7/+OqZMmRIxxWKabqU20ojy8OHDWLp0Kc477zzMnTsXTU1NcLvdyMjIwOjRo+0kKTk5GV6vNyqA8f9NIz9Tn3Dwe48ePYpFixZh0KBBtr3RYjY90NyzZ09Y1qm1xMWLF2Px4sVwu9246qqr0LFjRwSDQbvNlZWVWLVqFQoLCxEIBPDFF1/gww8/xJVXXokdO3bgk08+QYcOHf4/9t47PKoj6R4+M6MsoQRCEZEEIoMxGDDZYIIJNsGJdQ7rHHZxXEcc16zXYZ3T4sDa64SxwYDJxsZgchIZBAiQAAllaRRm7vcHv7quKfVIwh52199b53n0SLrTt7u6urpOdXXfO/jpp5+wZ88etG7dGrfffru9v7Vt2zaUlpbizjvvRExMDAoKCrBkyRIcPnwYGzduRO/evZGYmIj169dj06ZNOHjwIHbv3m3Pk+TkZERFRdnEmJSUZB9OOX78uD1+27dvx6pVq3D99dejY8eOdpqytLQULpcLKSkpmDp1Ktq3b4/nn38ebdq0QZcuXezVlcwkmPTN0+i7du3C7t276/XJp4P/aXIBgM8//xznn39+nejZ3/KaPpN5T4oG6Y3IAHy+x4NSW4cOHcKzzz6L3NxcbNmyBW+88QaSkpLw9ttvIyUlBRdeeCFWrlyJNWvW4LzzzsOcOXN8Jn1tbS0WLFiAV199FUlJSXjggQfgdrsxbNgwewkuo9ji4mJs27YNl156KUJCQjB//nyEhYVh9OjRePLJJ/HXv/4VI0aMwJAhQ5CTk4OcnBzs27cP55xzDvr374/nnnsObrcbHo8HMTExiI6ORtOmTeuQB+movLwchw8fRk5ODrKzs5Geno6amhrk5ORg7dq1mD59OsLCwrBs2TIcP34caWlpProk/UVERGDixIn2aTm5Hwb4voWWp1TKysqQlZWFu+++246ga2trcezYMeTn5+Pyyy9Hz549UVZWhsjISBQVFeGzzz7D/PnzccUVV2DcuHF2tJ2Xl4e33noLsbGxKCgoQEFBAe6++26ffDJPO9G1JUuWYMiQIUhPT4fL5cLJkyfxzjvvYM+ePejTpw+uvvpq+0QhOWJyMACQkpKCkydP2seqKb118uRJrF+/HsuXL0dKSgq++OILlJSUYMqUKejTpw+2bt2KxMREdO7cGS1btsSGDRtw+eWXIyoqCgcPHsSsWbMwatQoOBwOHDt2zE4bkr0sWbIEW7ZswZgxY+w9mNraWqxatQrBwcG46KKL0Lx5c8yePRv9+vXDuHHj7H0z0onphBeN7YYNGzBz5ky4XC47xdOhQwc0b94cHo8Hu3btwqZNm1BaWork5GQMGTIEaWlpdVa2ptUIjX11dTViYmJ85jS/n2Rxu9349ttvUVBQgHHjxtkr8ri4OGzbtg3FxcUYOHAgmjVrhpKSEqxYsQKffvopkpOTMWXKFPTs2dMm8YyMDMTExGDr1q3IzMzEqFGj7Kfgr7rqKmRkZKBbt26YM2cOvvzyS5x33nno0KEDCgsL7VTuoUOHsHXrVlx33XVIS0uzH4Bt3bo1zj//fGRlZWH16tVYtWoV4uLiMGTIEBw/fhx79+5F06ZNcd5552Hjxo344YcfcPjwYbRs2RLDhw9HeHi4fSovMTERQUFB+Pnnn5GWloa8vDwcOXIETqcThw8fRseOHREfH49JkybB5XJh165dyMnJwaBBg+DxeFBUVGQ/S+NyuRAVFYXw8HCf48hEQPR8mMfjwbffflvnyPNvwf88uezfv99nCS+ZGKj/VRwAfFJmRDqJiYk+ZelrY1u3bo3JkycjKioK06ZNQ2RkJN5//33s3r0b06ZNQ2xsLEaOHImZM2eiX79+qKmpwebNmzFy5Eg7XRASEoIhQ4bA4/Fg2rRpaNu2LXr27GkkPXpeY+fOnRgxYgQWL16M7OxsjB07FmVlZdixYwcKCwtRWFiI7t27Iz4+HrW1tWjZsiUyMzPx/fffIyUlBREREXaa5ayzzoLX67U3xU+cOGGfbOvQoQP279+P2tpadOvWDStXrkS/fv0AABUVFSgpKUFcXBxSU1Nx//33o0mTJsjJyUHTpk0RHh7uk3ICTm2uyz0umariq0simIMHDyIsLAzt27dHUFCQnQ9fv349LMtC9+7d7RTEjh077BdjTpgwAUePHrUdvNvtxsKFC9G6dWtcfvnlWL9+PZ5//nncfPPN9iktuYLKysrCnj17MGLECJ+AZOPGjaiursb999+PV155BStWrMAFF1zg45T5/lNISIidZ/d6vYiKikJJSQlWr16NwsJCtG7dGocOHcKQIUPwz3/+E6tXr0bPnj3Rs2dPxMbGIiIiAidOnECzZs3QtGlT26G0atXKdhRVVVUoKyuDw+FAaGgo9u7di82bN+PKK6+0N68dDgdKS0vx448/YsCAAWjTpg0++OADjBw50k4jcQKRZCvfS0b7kBMnTsTQoUPtwxpVVVVYvnw5Dh06hLPOOgsRERHYvHkzXnzxRXTv3h3R0dEYNGiQ/cwTHYYpKipCeHg4IiMjcfz4cXz77bc4cuQIbrnlFjslylNmJFttbS0OHjxo22haWhoAIDIyEvHx8Vi5ciWCgoJw4YUXYtmyZdi2bRvWrl2LoUOHYuzYsUhMTITH48GePXuwYsUKpKWlYd26ddi2bRsuueQShISE2POLyLG2thbr1q2z37ixdetWXHXVVaiqqsKiRYuwbt06dOvWDRkZGaitrcXSpUtRU1ODm2++GTExMbYezj77bHTv3h2RkZHYvHkzevTogWHDhqFnz54oLi7G0qVLMX78eIwYMcI+1l1WVoacnByMHj0arVq1wtChQ7F06VJs3rwZmZmZyMzMRN++fRETE2MHbA6HA02aNEFiYiLmz5+Pffv22d9U2alTJ6Snp9f5llVO+jROx44dw+bNm0/TO9eP/3lyOXLkCHbs2IFOnTrZ1/ydeAHqvsaDR9ROpxMnTpxAbm6uzysoqExKSgp69OiB3r17IywsDP3798ebb76JxMRE3HnnnUhOToZlWbjkkktw4MABrFu3DnfccYf9DABFiB07dsT06dPRtGlTFBUV4dJLL0VKSootM5fd6/UiPDwcaWlp9mrn5ptvRmpqKhYsWIC2bdvigQcesCOyfv36wePxICcnB2+88QYiIiJw3XXX2fslXq8X7dq1A3DqHUxHjhzBa6+9ZpMipWUmTZqEiooK/OMf/8CKFSsQHR2NY8eO2afmgoODERoais8//xxt27bFRRdd5HP6hG8i06TkzoH6Znp2oba2Ftu3b0dSUhISExPtJTxN7L59+yIpKckut2/fPliWhfvuuw/Hjx+3o+aIiAisWLECO3bswNSpU+33vcXFxfnIycmQHAI9m0POuaSkBBs2bLAntsvlwvHjx23HS6tcvl/mdDoRHh6OiooKBAcH2ymiQYMGoaamBm+99Zb9RPnll1+OrVu34r333sMFF1xgp3BKS0vtZ4Sqqqqwf/9+OzABgMOHD+Pdd9/FbbfdhtTUVPz888/o1asXEhMTbQfo8XgQHByMcePGwbIsvP322xg1ahTGjBnjM0ZyhUJ2yE+JAcDevXsREhKCnj17IiwszF7tzpo1C4WFhbjqqqsQGxtr2yG9RsiyTh2YueSSS1BZWYkdO3Zg+/bt2L9/PxITEzFkyBDMmjULCQkJOHnyJI4fP44TJ06goqIC7dq1s990UV1dbUfac+fOhcfjwcSJE+1gISgoCG3btsWPP/6IMWPGwOE4ddQ9Pz8fCQkJmDx5sr05Tnukhw4dwgcffAC3241rr70WKSkpNvFlZmbadYeHhyM9PR3Z2dlYtGgRxo4diy5duiA7Oxuffvopunfvbmch9u/fj8WLF2PKlCnIzMyE0+nEQw89ZAeqlFLt1q0b2rdvj6ioKDgcDtxxxx1wu91IS0vzIf78/Hy0atUKvXr1QkhICEaOHIkhQ4bYD8LS4xQcDocD6enpuOuuu7BlyxbExMQgJSUFsbGxdnt81cpT8jxF+dNPPyE/P//0HXQ9+J8nl6NHj2LHjh3o2LGjzxl8GZHSNXk8kkfUAJCQkIDBgwfb0TrdBwDp6em47777kJCQAJfLhalTpyIvLw/NmzdH8+bN7Qmanp6Op59+GlVVVYiNjcXGjRvx9ttvY9myZZgyZQo6duyIQYMGYfPmzXjggQcwcOBA4wEDIsCIiAg89NBDyMrKQrt27ZCWloaqqip07doVrVu3xllnnYWEhAS8+uqrWL16NRISEnDBBRcgISEBPXv2BACsXbsWADBhwgR7v6FXr17Ys2cPevfujc6dOyMiIgK1tbU4//zzERsbi8rKSkyZMgWfffYZkpKSMGzYMJx33nn45z//aa+Ghg8fjn79+tnOQ+bQTTo2bejKU10ejwehoaFwuVz2G5gty0K/fv3Qo0cP+5DFvn37UFtbiwsvvBCtWrWCw+HAkSNHsHXrVsTHx+P777/HxRdfjKZNm+LEiRNYunQpgoODsXTpUqSmpiIhIQHx8fE+D/2tX78eo0aN8iGKn3/+GeXl5Wjfvj1ycnKQl5eHoqIizJo1C16vF2lpaejSpYudZuRpHyJGOrBAx1PT0tLgdDoxZswYtGnTBgMHDsSSJUvw9ddf46yzzkLr1q1RXV2NXr162ScLaeVIddO3D7Zo0QKlpaU4fPgwevbsaX9OpB4WFoZ+/frhlVdeQUZGBsaPH2+PhdvttlceTqcTkZGRxndP0Z7Xp59+iosuuggJCQn2XNq9ezfmzp2Lu+66y14xHTlyBJ9//jkGDBiAyZMn49tvv8Xu3btRW1uLFStW4PPPP8e4ceNwySWX4Mknn8TWrVsxfvx4hIeHY9++fVi6dKnPu/xcLpcd9ffp0wfx8fGIjo7GhRde6PM2DYfDgczMTHTs2BEXXHABWrRogbPOOguvv/46LMuy35t34sQJdOvWDQMHDoTb7YZlWRg2bBhSU1Pt1ODw4cMRERFhpx3DwsJw6aWXok+fPvZJPqfTiRYtWuCWW25Bp06d0Lx5cwBA06ZNcfvtt9tfOwzAfmaMgx5hICQlJdkBD/cJzZo1w7BhwxAbGwsAdkqLwO+RB1datmxpp6/9bSH4O61XVVWFlStX/qY3IJvwP08u9HZQyg+SgzI5K/nEOt/0B2APwl//+leEhYXVeXUIOQQakNjYWMTGxvoQGe0hxMXF2UTXt29fdOjQAcXFxfYG9fTp0+3nC/hRYALfnwBOvXomPT3djmBpkxI4dTqnQ4cOeOaZZ1BeXo6oqCiEhobaxFhTU4OYmBh7kpATGTZsGIYNG+bTflhYmH04ICoqCuPGjbNPo0VERKB9+/Y4dOgQoqKikJycjCZNmvgYqSQYnl7hz3IQyHnzCeHxeOyNb1o5VFdXw+VyYfz48T59o6fBzz//fISGhqJly5a4/vrrsX//frzyyisYNmwYMjMzsWnTJnz88cfYtWsXMjMzsX79emzfvh2FhYXIyMiwU520GZ+enm63UVhYiDlz5mD48OHYuXMnPv/8czRp0sTecwgJCUFoaCiqq6tt0qO0DaWrQkND7aPUFBXSao9+YmNjMX78eDtdZFkWevTogZSUFFsv1Bbpqqqqyk5LEdauXYuQkBD7CHt0dLS90jt69CgyMzOxf/9+lJeXo7q6GuvXr0d5eTlSUlLQvXt3tG3b1hgQeL1e5Ofnw+122w+wEuikWEJCgq23yspKFBUVISMjAzt27MDGjRsxbtw4lJWV4ZtvvkFiYiLOO+88lJSUIDY2Fueddx6GDRuGOXPmICsrC+Xl5bj99tsRFRWFdevWwev1okePHvaeg8vlwg033ODjVAndu3dH69atER8fbz//MWzYMEyfPh1vvPEGBg0ahPHjxyM1NRUOhwNXXnklLMuySZUOlyQnJ9dx2AkJCUhISPA5th0ZGYlBgwb5pHybNGlipwClwyeZpU+iv+UKwrIsxMTE+KS8eFmereEHmOReouk+GRDK4+jFxcV2cBpI/M+TCwDMnz8fN9xwg73xxFNfHLSvAtT9PhVStFyy0qDQ55zd5QTkBEO/aeDouCJdczqd9rMvPAUhNzp53SSPXHVRX6KiohAZGVnn1E9oaKjPUVN5ao6n4rgsJCdtrNbW1qJJkybo0qWLTaJUF7+PftPTxh9++CESExMxatQohIWF2ZNX9pXOz1uWZeeeadVC/ZZPV/fs2RPdunWzHazL5UKvXr2wb98+JCUl4cILL0RNTQ3mzZuH3NxcPP744z5RLr11gSJHh8OBiRMnIj4+Hh7PqVeVz5gxA5mZmejevTs+++wzDBgwAAMHDrSPn/Kx4GTJx8DtdiM7O9t44ITskpwJfU8OrThI1qqqKkRGRtp2Q1/pUFRUZKcBx44diyVLluDf//43IiIi0KlTJ3Tu3NmWp3///li4cCG2bNmC8vJyO1ffuXNnpKam+jwzxY9gA6dOZ65atQopKSlo2rSpz8rOsiz7mSuyo+TkZHTr1g3/+te/EBQUhAEDBqBXr16orKxEdXU1Lr30UkRGRiI4OBh/+ctf0Lx5cwQHB6NTp06YMGECzjvvPCQlJcHlcmH06NG2Lvn72fzNdYfDYUf4dF+3bt3wj3/8A06n035CneyQP8/CHTvdz+cOt3VOEHK+yv/5uFMb/u6tjzRMPoiXkyRGejJtF1C9phULYd68eaisrKwj52+Fw5It+SsoHO1/EgkJCdi8eTOioqKMA04rGdMJFe5k+YkfnkYD6n9RHbUhH6YiSPLgz0LwduU+Bd1L9/DnDKhNkpfrX6b95ITg7XASofIkP38mh47i0ud8lSgJCjjl+CorKzF79mysWLECDz74IFJTU32cuDxEQTqhh9zcbredRuD6Mn3JEZfLsiyUl5fbex50ygyA/SwMyWmqi3+nhsdz6k0QycnJCAsLs1eNvN8kH9kdnQrkNvD999/D5XJh8ODBPpOZ9CD7yMeXxsrtdiMnJwfp6ekICgqyv/+jqqrK58n8qqoqm2gjIiLqPI9TUFCA2tpa+8ABf8CX5okkPxqXNWvWICcnBxdccAFiYmJsfeXl5SE7OxtnnXWW/aojemD35MmT9mqengnLzc1FamqqfViDxpV0Qfts/IcHgHy1IueEyflyHcjnm3j9fC7IVQUnHf6AKJ8HvE0Of4TAdc2dP8EfaUjZJUmZAhgpiwxOJckAp16z9dBDD532yqUxtPG7IJeoqCjMmzcP3bt3B+DL0vQ/5Z5pSUlpB54SokEiB8H/pnroCV+CKTIAzBuiNBnkyoOrmNojR8lPj/Gjurwt+WZb6htP69EEpnp49E9t8T7xiJTrkBwu9ZcfXSTjpPbz8vLw6KOPYuLEiXa6R0Zs8vXu1H/eBl+JSV3z1BmPQMkJkNykby4nwbQClZMTgM8JHFN57iyIYPgYe71e+2inJHzufHhwI9vjRER/S4L0er0+OXw+9nR0mDtD/hJMTi78wVzpqGRAw986we1WBh3SKcq9OUkW/DPpiOWKWf7U5/RlpG5yuGTbfD7Q+JjqNpGGJCYehMgyprQ9DzI5KXL7lv2V7fJgV84NPg7Srh0OBzZv3oypU6eioqICp4PG0MbvIi1WUVGB+fPn21/Hy1NfAHyMGaj7JUo81UJGxCe7TItROe5U6Bq1yyNSGeFSGZMDkcZIn3Hjl6sSU1RjkpWvmLih835wmXkbBPmlVaZ6uawJCQn2ipK3K8eAr9B4n0n/vH2uL6k7uTI1TRoCleXvY+Lycbsh2SQRUz3cMUjHSn2oL7/O+yHtRK6W5WeyHf6sDdclf38er0/aKf9c9t3kwHg73JZ4Gd4nqQMuE08P8v7JPRVpZ7wN02qCtynnrdxT4fOVjy9/7k3qSM5rOba8/5yoZJtcl6QPGj/+t8lWqLwcCznmUnY5Dnw+/fzzz6dNLI3F74JcvF6v/c2U/LstuOK4A+EDTs9HmAaLk4qEKUoybZhJOUyGR+V4RMPLyOUrNzD5fA8/MUd1mgyITi1xGagNXr/8W04W2p/iUTDdEx0djRtvvNFOu3BHzesgRyFl5TrgETF35jTh+EqITywZYVuWZT+NLUlBjpGc8PyadAjcFnj0TbLL+3k9XKemtngaU+rFREycxOUbvHlAwfdUpP5N8sm/5fyQ5akeGbBIPUsdyKicl6lvLvEMgyl4485TjqHUr6kN/qCqqX5/Y+tPdp4d4eMvgyX+2+QjZDDJ5ZaBLteXaa+Fz/Xq6mp8//33dXQSKPwuyAUA1q1bh9zc3DpfTiRXDTy6oYkn016c7bnxAfVPaumo+W/pqLixUD0yCpHGwh2qyWCpnDQiLif/nx9+4J/JqNC0R8BfZkm6k86H3i3mcDh8Nuu58/V6vca0FZdZ6svkcPiY80ki9cTJjDsM0yT2N1nlJOSymNI6Jhn4ao/GVI67fB26HGfp6PkKQ5Iiv0euzLnsNJZ8BSFtgutBjockB94frkc+3qb5Kfsonww32Qa/blqJyDplwMSv8aDKtFrjzpxWhKYVsClAkWNXn75In6aDSPUFOnLlI+c/75ME1fnzzz/bXwl9JvC7IZddu3ahsLDQfhiRD740PO4w5ZfnyPSTKfIxQUb33OnJyE06Hrof8D39wp2cNG5+vzx2zctzw5QODoAdxfPP5R4HTxvKiSdXHdwpm1Yosn+yHzLq5nrnkR4fW56u4n3g+zF8nKl9qofvM/DPTfridsIdgnSMBBkx8zqAXxyTadXib9z5isbkIGU5KbepX9wRk05MTov0Jtsj+U3pG05c1K7cjPc3J7iscrXA5aI6ZT0yEOKEYCIc/j9vR85t/rmc26a+cPn9OXS+N8Z1wNPH/lL+UsdcZi6Xyd9IUvJ6vfY71c7EKTHC74Zc6CWWnTt3tq9JggDqriZkBEanbOj++u4zRZOme/wRk78JxY3DlBKRk42Mkjac+WpEEqzsAy9DfxPh8KiR/89XKdIRyM1oKiMduFxdmRwFr1c6Udkv6YjoUICJ0El3pF+5CpHO2t+q1J9T4qjPgUndm+Q0XTO1Y1pV1OdgZJQsI26qh9/Ho2hKU5qCBJNscjXGyYjbekNOnfePB22yn3KVKOel1Lu0Aa53eV3+Lb8OWvaZz5f6fIbJRrgd88BLbsbza7IdngkwzR/p0yzr1PsMz2RKDPgdkQsAzJ49G6NHjwaAOgMtlc8/A3wdtsko/Dk46ZRMJCJXQ7w+ueLh8siIlhMP9ZGvwvgk4u2Yoh5ZP3cS/M3FfFXCJzOvl08sXie/xzS5ZF94n6g/MjjgXzjGV3W8Dn/OjDtVusbTLSQf36cx2QqHjKZlWX9RNv1tmti8nKl+ScbSpv39LcmddMz1ZIqu5RhyWbht83pllO9PTmkrXFZ/kb7UkxwXuS9hmuP8PtNKjOuWl5fEIlfjBJnmlH2l+k1kKlflfJUtU9RSLzIolO1xncmx5P5ox44dKCgoqKOTQOJ3RS7Z2dn2t0KaIhBuCHJJyycaj4TkgJjISTo5Wb9c/psiFP6b3wf4pq78TWY+EaTRcYdimhBcJn5U1t8JJ7lq4Hoz7QdJApWOhstO9XAZ/TkofwcXuB5obOSKUDpo/jc/JOAvqpQ64TKZjpTKMeDlac+JBwv+VjT+yEeOtT+HSfdQWZLH37NXpoBAOm1JWLJuKkty8RWPHAN5etGkf3nNRO6SGEzjxZ25yWFLEpXg7Zr8DX3Oj6RzHfL5w6/JNJi/fvM2uI+T84D7IHm/1Ae1v2jRImOfA4nfFbnQq6vbt29fZ4OZII2dIlUqS0+D8/LSmUvHJ5fdBP4QIpXlk1WufKQDl+XpOpeLOym6Ts+OEMmaJqmcfNxA5d9A3S+e4p/J+3k75Cxl27Iu3jepG+mwTLrwd43L6m9yklOTz3OQIzT1019feR9NepbgQQR3rjyqJsg+mYIl/hlHY0lIErW0N9lfbj8kr5wnPCDizo7r1N8ckmPI/zc5d39lZb+lXco0kylIq28cTfJLe/A313hfZH94EMhlk7rhfTOdWpV+iLchr9P3y5xp/K7IJTc3F1lZWWjfvr0PUwO/DL50FvKkmEybmKI6qk9uCvLNZt42NzKZ6uH5a1mW6uAv5JOb2dxQTI6C7qfyMiJyOHxffcFXSfS36YQWhz+nyyepaXJIZ87rk/dTH/lYVldXw+Fw2A+RUlm+epLOkveDt8GjOznudApIHgDgfZeRPv8tx9b0FDxBPvtjctxSfnkk2LSalTrguudyUEDC9Wcabznu/v43rWRNhMg/l+3wuuV103zh4+5Pdt6+iThNNiNtnDtyfl1ek6TK65EPL0sC44QkA0V/99H/Jj9BkATE59quXbvsN1qcSfyuyKWmpgbHjh3zOa0iTxfx47d80sm0CU9X8OiNR7PSYfKIjdcl00iyjFwp8bL+jJmcnDwmSX/LjVM+Aal9fniBvzJePsgoIy7eb97H+iI3/mwJJ0LpmGTaj08CKRNfdZr0Y3K8Uie8XnqOBvglXSUPM8iJKCEnsvxb1iPH3bTC4M5JkqKpbZMNUp9kWW5vprc0cJ1xGTn5cl3LlCD9JtLk7y7j8so2ZRn6WwY7/srJ+SdXh7wfpvEwEYVcbcmxkxkJ2QbpwWTXsh4aa35YR+pWngKVBCMDBF6G79Ny3Xk8HixcuLCObGcCdTXwP46FCxfar8/mExHwjfx4Dlg6Tuk0qTz90Ks95OTjf/OBl4YvjZ8bAHcMnAToc2qXrlFbdK98HoAMiJfloGsyQuVy8/upn3xjnbdNuuHRM31OzprXKT+XUT/XCdczH0deL++HdB48TemvvzTx6H76TPZHjpkEH2+TbNKRSgLhzoDLa9KNdPJSRq4/qUPeFumHj7skGa4faUe8HIecL9IepX5MKwTeVzkXqX3TGPmzaVmv6Zo/O6Hf8gi/KYCRxCNXvNzm5FwzEa/0X9LepU8yzV2TrCRHdnY2Dh06ZBzHQON3tXIBgKysLPvV53zVwqMt2mDjS1+g7qku02Y2DShfMciIXhqq/DFF+DJq4vtAVJ6naegVH/S53DTkMpOB8fc/ydQOr4uviqisaQUgdUJ1SwLlk57k8VeHTAvwCcFfBslTS/xv6fi4LKYgw5Q+4JG+dHRy1SZtjMDrlP03ySUdgyQW07hKZy2vy7I84PGnG/qSPNNqmPprct5yb4X3ne/X8bSrXKlSX6Xjput8Ze0vBSznmZRFjp3Uo+lEKcnK/zbZktQtb1+SqEyfy702qsN0Ek2Wk21Tew0FjJKUvF4v1q1bh9LS0jp1nwn87sjF7XZj7969OOuss+qkEuQSWj69CvziPPgGr3R60hDk5KDfpijClOv0l8KSpMjvkU6BGyJPazmdTvv7vSn1YyI66XC43NxxylQLtcflkXXJaFw6UT5RpTxcL6brPEgwTSSSjT8IapK3Pkcq0w/8bznRpT3xMZNpC9N4mu7lOpBpD5Ne/AUAZAP8h0OSj0mX8lSe6Quk5JjzvpkcKP0vvz+J91VG6nzucoLmY0Zy8oco+fzj84T3keYjBVwygJCpV5rD0nb53DHNM/5b7k2ZCJL7Fq4jHgDK8TOtZni9/POioiKsXLmyzvifKfwuyWXx4sXo1q0bAN8z7yal+Ys05MqFjIxPEDIoOQF43fX9z6MLHslImfiGPnd2ckUjU3zyPVtcdm6o1G+5t2DK6UryNDlHSXr+Uia8r6aVD7+fE7pJp/7kkysdk3Om3ybHb/pckqU/m5J6Mjl1f23Lic9tho+JlIPsgNct9ccdJK/fFPjwv6Vsss8y8OB65nNIvv+P2y7dL1dP/rICfL7yzzkB8j1Yuo/LIE/k8XGQ6W2uYymP1AcFlBImEuL1Sj/B9cv/l/KaSMNEWPI+0s3x48exb9++OvKeKfzuyMXr9WLfvn04fPiw/SVZwcHBcDpPfW0pf102GTp3YFQHN0JuuLSspwHhpEBO218EYTrtY9oA5UYnIyU+GfmE55EayUbHkaUzpjLc6Hi/TZNUOmTTCoX3Vf5vWhFwmaRe+LMmnDD4PXICmRyb6W/uvHi9Modumpxy5cLvl5PfFAzwNxOb6pIOQOpU2oY/p8LlMhGhP5ug//nDe6ZxlGlAOT4cnPRl26R3SWxSF/5sjZOP6SWlpnp4/+R98kl7qUdJ0lLX1B9+MESuSuR8kGQqyd+kAzk2fHw5mUq78kfGALBgwYKAf5VxffjdkQsALF68GBs2bPD5Qh8enXMn7G9FQ5CDxK/XB9mG6VpjZCMC5IRIv/kPAPtECZ8sdDrH4XDYJOt0/vItklSWvoGT7uc/TqcTISEh9t/0m96IbCISU6qHr9JMTpLup8nPCZmPgyRGqUdT5MePY8tX1JjGyfS/3KOT4yDl4f2U4+dv3AmmyNUfuXAZpROVnzfW5qXzoz7wMlI2gnRq/F5p4/X1mV/n4+GvnD9HaiJrGVCYVka8bXLmUnfcDk1pbWqDk43UmyQGbiNcNtkfmidcp1wG+VuOBa+voKAAu3btMur1TOF3SS7l5eUoLy//b4uhCACkM5d/+yNxf0QO+E4u7uDpM3/On39mInn+mb/PTX/z4AGo6zyl02yMnkyEbyJN+TnpgK8ypdz8Pq43k36kTvgbIKR++PNE8i0R/D5ZzvRzOrqUepDETKtnCr4oQOHfmyPJmKfD+Oqb68y0t8T1zeXnsvG9M7pHEp+/AIJIkr8lweFwYPfu3Th48KDRts4Ufpfkovj/D0zpG8V/FnKF8WvL1fe5v89M1xt77deivvrr++2PrP0FK/6CG39ZClNgI0nYRNSmAId/D5PT6cTWrVv/oykxQMlFofg/j8aSupK/4nTwu3uIUqFQKBT/+2j0ykWjFoVCoVA0FrpyUSgUCkXAoeSiUCgUioBDyUWhUCgUAYeSi0KhUCgCDiUXhUKhUAQcSi4KhUKhCDiUXBQKhUIRcCi5KBQKhSLgUHJRKBQKRcCh5KJQKBSKgEPJRaFQKBQBh5KLQqFQKAIOJReFQqFQBBxKLgqFQqEIOJRcFAqFQhFwKLkoFAqFIuBQclEoFApFwKHkolAoFIqAQ8lFoVAoFAGHkotCoVAoAg4lF4VCoVAEHEouCoVCoQg4lFwUCoVCEXAouSgUCoUi4FByUSgUCkXAoeSiUCgUioBDyUWhUCgUAYeSi0KhUCgCDiUXhUKhUAQcSi4KhUKhCDiUXBQKhUIRcCi5KBQKhSLgUHJRKBQKRcCh5KJQKBSKgEPJRaFQKBQBh5KLQqFQKAIOJReFQqFQBBxKLgqFQqEIOJRcFAqFQhFwKLkoFAqFIuBQclEoFApFwKHkolAoFIqAQ8lFoVAoFAGHkotCoVAoAg4lF4VCoVAEHEouCoVCoQg4lFwUCoVCEXAouSgUCoUi4FByUSgUCkXAoeSiUCgUioBDyUWhUCgUAYeSi0KhUCgCDiUXhUKhUAQcSi4KhUKhCDiUXBQKhUIRcCi5KBQKhSLgUHJRKBQKRcCh5KJQKBSKgEPJRaFQKBQBh5KLQqFQKAIOJReFQqFQBBxKLgqFQqEIOJRcFAqFQhFwKLkoFAqFIuBQclEoFApFwKHkolAoFIqAQ8lFoVAoFAGHkotCoVAoAg4lF4VCoVAEHEouCoVCoQg4lFwUCoVCEXAouSgUCoUi4FByUSgUCkXAoeSiUCgUioBDyUWhUCgUAYeSi0KhUCgCDiUXhUKhUAQcSi4KhUKhCDiUXBQKhUIRcCi5KBQKhSLgUHJRKBQKRcCh5KJQKBSKgEPJRaFQKBQBh5KLQqFQKAIOJReFQqFQBBxKLgqFQqEIOJRcFAqFQhFwKLkoFAqFIuBQclEoFApFwKHkolAoFIqAQ8lFoVAoFAGHkotCoVAoAg4lF4VCoVAEHEouCoVCoQg4lFwUCoVCEXAouSgUCoUi4FByUSgUCkXAoeSiUCgUioBDyUWhUCgUAYeSi0KhUCgCDiUXhUKhUAQcSi4KhUKhCDiUXBQKhUIRcCi5KBQKhSLgUHJRKBQKRcCh5KJQKBSKgEPJRaFQKBQBh5KLQqFQKAIOJReFQqFQBBxKLgqFQqEIOJRcFAqFQhFwKLkoFAqFIuBQclEoFApFwKHkolAoFIqAQ8lFoVAoFAGHkotCoVAoAg4lF4VCoVAEHEouit89rrnmGrRq1eq/Lcb/BB5//HE4HI7/thgKhZKL4vTw/vvvw+Fw2D9BQUFITU3FNddcgyNHjvy3xfuP45prrvHRB/8JCwv7b4unUPzXEPTfFkDx+8QTTzyB1q1bw+12Y/Xq1Xj//ffx448/Ytu2bf/nnGpoaCjefffdOtddLtd/XJaHH34YDzzwwH+8XYVCQslF8aswevRo9OrVCwBwww03oFmzZnjuuefwzTff4JJLLvkvS/efRVBQEK644orTvq+8vByRkZEBlyUoSKe14r8PTYspAoKBAwcCAPbt2wcAqK6uxqOPPoqzzz4bMTExiIyMxMCBA7Fs2TKf+w4cOACHw4Hnn38eb7/9Ntq2bYvQ0FD07t0ba9eurdPO7Nmz0aVLF4SFhaFLly746quvjPKUl5dj6tSpaNGiBUJDQ5GZmYnnn38elmX5lHM4HLj99tvx+eefo1OnTggPD0e/fv2wdetWAMBbb72FjIwMhIWFYciQIThw4MCv0g+lE7///nvceuutaN68OdLS0gAABw8exK233orMzEyEh4ejadOmuPjii+u0VVNTg2nTpqFdu3YICwtD06ZNMWDAACxatMguY9pzoT6S7kJDQ9G5c2csWLCgjpzLly9Hr169EBYWhrZt2+Ktt97SfRzFr4KGOIqAgBxhXFwcAKCkpATvvvsuLr/8ctx4440oLS3Fe++9h5EjR2LNmjXo0aOHz/0ff/wxSktLcdNNN8HhcGD69OmYOHEi9u/fj+DgYADAwoULMWnSJHTq1AnPPvssCgoKcO2119pOmmBZFsaPH49ly5bh+uuvR48ePfDdd9/h3nvvxZEjR/Diiy/6lP/hhx/wzTff4LbbbgMAPPvssxg7dizuu+8+vP7667j11ltRWFiI6dOn47rrrsPSpUvr9D8/P7/OtZCQEERHR/tcu/XWW5GQkIBHH30U5eXlAIC1a9fip59+wmWXXYa0tDQcOHAAb7zxBoYMGYLt27cjIiICwCniePbZZ3HDDTfgnHPOQUlJCdatW4cNGzbg/PPPr3d8fvzxR8yaNQu33normjRpgn/84x+YNGkSDh06hKZNmwIANm7ciFGjRiE5ORnTpk2Dx+PBE088gYSEhHrrViiMsBSK08CMGTMsANbixYutEydOWDk5OdYXX3xhJSQkWKGhoVZOTo5lWZZVW1trVVVV+dxbWFhoJSYmWtddd519LTs72wJgNW3a1Dp58qR9/euvv7YAWHPmzLGv9ejRw0pOTraKiorsawsXLrQAWC1btrSvzZ492wJgPfXUUz7tT5482XI4HNbevXvtawCs0NBQKzs727721ltvWQCspKQkq6SkxL7+4IMPWgB8yl599dUWAOPPyJEj6+htwIABVm1trY9cFRUVdfS8atUqC4D14Ycf2te6d+9ujRkzpk5Zjscee8yS0xqAFRIS4tPvzZs3WwCsV155xb42btw4KyIiwjpy5Ih9bc+ePVZQUFCdOhWKhqArF8WvwvDhw33+b9WqFWbOnGmvIlwul72h7fV6UVRUBK/Xi169emHDhg116rv00kvtVQ/wS5pt//79AIDc3Fxs2rQJDzzwAGJiYuxy559/Pjp16mSvAgBg3rx5cLlcuPPOO33amDp1Kr744gvMnz8ft99+u3192LBhPkeZ+/TpAwCYNGkSmjRpUuf6/v37fcqHhYVhzpw5dfrUrFmzOtduvPHGOhv94eHh9t81NTUoKSlBRkYGYmNjsWHDBlx55ZUAgNjYWGRlZWHPnj1o165dnbrrw/Dhw9G2bVv7/27duiE6OtrWr8fjweLFizFhwgSkpKTY5TIyMjB69Ghj/xSK+qDkovhVeO2119C+fXsUFxfjn//8J1asWIHQ0FCfMh988AH+/ve/Y+fOnaipqbGvt27duk596enpPv8T0RQWFgI4tS8BwOhUMzMzfQjr4MGDSElJ8SEGAOjYsaNPXf7aJvJq0aKF8TrJRHC5XHXI1h9Mfa+srMSzzz6LGTNm4MiRIz77QsXFxfbfTzzxBC688EK0b98eXbp0wahRo3DllVeiW7duDbYr+wic0jH15fjx46isrERGRkadcqZrCkVD0A19xa/COeecg+HDh2PSpEn45ptv0KVLF0yZMgVlZWUAgJkzZ+Kaa65B27Zt8d5772HBggVYtGgRzjvvPHi93jr1+Tu2a4kN+DMBf22fCZn4KoVwxx134Omnn8Yll1yCzz77DAsXLsSiRYvQtGlTH10NGjQI+/btwz//+U906dIF7777Lnr27Gk8Bv2f6ItCUR+UXBS/GS6XC88++yyOHj2KV199FQDwxRdfoE2bNpg1axauvPJKjBw5EsOHD4fb7f5VbbRs2RIAsGfPnjqf7dq1q07Zo0ePorS01Of6zp07fer6X8EXX3yBq6++Gn//+98xefJknH/++RgwYACKiorqlI2Pj8e1116LTz75BDk5OejWrRsef/zx3yxD8+bNERYWhr1799b5zHRNoWgISi6KgGDIkCE455xz8NJLL8HtdtuRMo+Mf/75Z6xatepX1Z+cnIwePXrggw8+8EkVLVq0CNu3b/cpe8EFF8Dj8dhER3jxxRfhcDgwevToXyXDmYLL5aqzgnjllVfg8Xh8rhUUFPj8HxUVhYyMDFRVVQVEhuHDh2P27Nk4evSofX3v3r2YP3/+b65f8X8PuueiCBjuvfdeXHzxxXj//fcxduxYzJo1CxMmTMCYMWOQnZ2NN998E506dbJTZ6eLZ599FmPGjMGAAQNw3XXX4eTJk3jllVfQuXNnnzrHjRuHoUOH4qGHHsKBAwfQvXt3LFy4EF9//TXuvvtun43tQKC2thYzZ840fjZhwoQGH5QcO3YsPvroI8TExKBTp05YtWoVFi9ebB8RJnTq1AlDhgzB2Wefjfj4eKxbtw5ffPGFz+GE34LHH38cCxcuRP/+/XHLLbfYBN2lSxds2rQpIG0o/u9AyUURMEycOBFt27bF888/j127diEvLw9vvfUWvvvuO3Tq1AkzZ87E559/juXLl/+q+keNGoXPP/8cDz/8MB588EG0bdsWM2bMwNdff+1Tp9PpxDfffINHH30Un376KWbMmIFWrVrhb3/7G6ZOnRqYzjJUVVXZJ7oksrOzGySXl19+GS6XC//617/gdrvRv39/LF68GCNHjvQpd+edd+Kbb77BwoULUVVVhZYtW+Kpp57CvffeG5B+nH322Zg/fz7uuecePPLII2jRogWeeOIJ7Nixw04pKhSNhcPSHT2FQlEPLrroIvsItELRWOiei0KhsFFZWenz/549ezBv3jwMGTLkvyOQ4ncLXbkoFAobycnJuOaaa9CmTRscPHgQb7zxBqqqqrBx48bTfnBT8X8buueiUChsjBo1Cp988gny8vIQGhqKfv364ZlnnlFiUZw2dOWiUCgUioBD91wUCoVCEXAouSgUCoUi4FByUSgUCkXAoRv6vwL+tqnkt/V5vV77Wm1tLYBTX0PrcDiM34h4um1S/fw1IVSP1+tFTU0NgoKC4HQ6fa7zcpZlwel0wrIsWJZly8bbczgc8Hq9CAoKsu+n+wg1NTXwer3wer1wOp12nVTG4XDYP7W1tfbrYZxOZ50XWXKZampq4HA47D5IPVB7dB/9kLwke01NjV1HUFCQ3VePxwOXy2XLZlkWXC4XPB6Pj8zUB4/HY9/r9Xrh8Xh8ZCCYxtvpdMLj8dhfQ0xyer1eH53zNqurq336Ultba5cNDg720YvT6fT5qgPLslBbW2vLR/dROeDUq/ZpvLgOSQ7qK8lTU1Nj38ttSNoN/e/xeGyZyV5Jd3wsuV1Sea4LekUO2bpJNl4PlaGx5bZF48jl4fdTWyZ74+NMeqCxJt3TPXze8THi48/th+aCnM9kI9QXbuNUD5eH2zGNO7cxGnNu61SG94HrgmQgfTXmC+SUXM4guNHyt9LyiROI+nk9ZKA0OehzMgzueEkO+ZtARk/18IktJzcZq5zI3HlzGfmk4U6PHDAZPMkkJxdvTzoCSQokN9XPnRuX2eRQZH+4rrjT4/eQ85aOlpwBb5v/yD5xGcgh8r+JpIl4uJzUT0nu1LZ0rJIYSGdUjtrgzlXasUmfvN9cFvqbxlnKAMCHJEluSfrcFuUP3ctll32XQRIvI/vGx4X3VRIUJ3JexvS+PSprChB5P3g5SYY8uOFjzH0Br5/qAuDzVRhUH9XD9cp9iAyk/EHJ5T8A6WTo799SHzdAqs/r9fpEtjJqoXJ8teBv5cMnDJWVTpocPo8WeYQunbkkIirD76XJQv9L58SduXQ2HNyhmxw2l9vkOLg8VD/p1h+RUXmSSU5qAo8U5bjSPdJJUnRM5fjKA4D9VdA8iOB2UltbW4eAZN/9BRm8Lhovvirnbcp+cF1wR2siAbIHGbzwOrnMpjkgyxJkoCQDE6kXWcZ0TTpb+l+SoiR4GTjw+3k7Uq9U3kRsJnLj9s3nO/cPfBxloCPr5qvbxkDJ5TdARmT1lZNGLf8+nTZltCUnh2kCy0hNOkEA9jJaGqJM+3ACIvB0Ea1WeARHsvH0lNQBJzE+IXm/Zbna2lqbdEzjIJ2gJDMexfnTL+8jn2xcn9L5cr3z+izL8iEprkP5N7+fdMoJl+uRVqIy4jaRKx9vU8DD6zGRFR9Tk7Pj42pyzjwtQ23wHx6AmFa5vC5JMPwzHqzIdnn52tpan5W8DG4kTPoykR2VkXORkwmfM2RfMk3N9czr5bZKY8ntna8K5djKsrJ/plSqKYVdH5RcfgOkA5IDSddk7tKUImsM6ouqpPFxOUzLWVO7MgqX9fD+8Fy/nITSyfFVFU1kvudC98jIl8tBToKn5njqSepByiydskz3yX0H2Xea/NzZ8bw1OS+6h/Y6+Fc9c+chV5O8TV4v77N07g6Hw95To3rkilSuBE3jw9slWfnYUf/9kTH/20Q6PAjjKzm+ypbt+1vV+tsLk2NG90oS4+2RXHxVyPUsdSZXVHIOyBWNJCk+F0xjYlrBcMhUrpwvBH/2YuoP7aOaVjA8BcfJr7EBsZLLGYDJSdKAc5Lxt/ow1cXLSafODUOSgyQ3OTFpYgUHB/sYlGk/xNQ/E/FYloXq6mo4nU6EhIT4RJDAL8ZPG5sykpIb6rRH5HA4UFVVZW+KSl1wh891wVdV1F9eN33Go3TpIGjFxXUknZR0fHxfgX7LyJlk5hOZO3fuaP1F7jR2NM50CIKPn3R+RFzcHuU4myDJixOOdJj8b+4wOfHR51x33ObkWMoVgmmuSfKntmVQR/13Op32CtgU/fOxpKCB7JScs+ngjOyzKTUn+2FKjfGxljZL91iW5bP3Jsdd2oxsj+uZyyADFCrTGCi5/Ao0lgi4cQCwjZATiyQZuk9GiDKykctW+l9OIE5u/iJTEyHxaI4MznRahSanaeVEaSt+v8vlQnV1tT0ZuG5IP1x+TppUl8mpmKI6rlc6pcWdtYx85XW5CUoymOqWkTP/TXJK3XPSk3qV/eROg/oaHBzsoy8+ppysuEM2Raj+SIj6LSNjf5Ezd568DakP3haH1AWlAukzSTZ8fvkLCiTB8BQmyUPkIoMAvpKV6TpOzKb5K8lO1uOP/GV/pI548CXJgxOFJCmpe1Nb3DZM959OSgxQcjmjkIMK1E0jmJaZ0ghl1EllpFPj7UgD423zNIo8wSKNjzsLThD8eKmUm9rwen2PAFO9cmOenLa/dAGvmya9KeqjPvJoXBKNyVlSmzx6p8854XCykbql+7huTTJKZ0RjTysJWU72n+uM60ISkT/nZrIlGitTOkzai8nByKiWk4M/J8fLS/nlalLaZH3Ru9yrkeRMwQXpnLftL0ig+zhJyhQqHx95ryRm09iaypjGj69+uUx8HEykZPIFvB6eGpOb+TL4aSyUXAIISSSU7pCGRJAOBTA7OII8fcPbpAnHjYY7RunUuJOR0SV3MlTW5FQk+fGcusmJUZ/pXsuy6hyFpOO1nFy5U+G64MTIdUY6JKLx12eSg2SgtniqkOudIDdcpXPmMvH/AdR59og7Pekc+A85RaqHnnHhxGiKZrndyfa4UzWtSHkfeMpFOn0uMz0HQ2QsCZO3wXVjWlGRnPwaD3hM5bg9cvDggMrwFGl9BCdX/DxDwO2Qy8mJn68iLcvyO+9NkP2SxGgiHqlD3h++TylXyKYAhqfLpQ01hEaTiz9Gb+x9/pj8dOozseZvufd07m9svdzhAr9EhZIQeDpMRmbSKXEZTXXz62RAdI0cPm+DGyjga2Qy9UD187w/te3PKfD7+f4Klaf8dkhIiN2+NHyqz0Sycvlvcgj0OTmQ+iYWgZ9yozQJ3w8hIpKBgpwbJnnkSsZkd0QQ0qHx8jK44OPEAxPTvVyvdD+3Db53w50Idyw0lnJ8pJPngYy0ddOKhhO/TPfycrzPvLzUMS/D73U4fkkrmfZ5OKGQ/XCikHPRFKDJeSCDD55e5rrg95tWDNRXPh78mpyLUr/+2qG/5RFqk/36s10TTvv1L7/VGZsgWbahsvyext5H95ieOwgE/BEfd9D1TXQeFUoikquD+trnZXmdcrLztrm8vAyf2DSBZTrAFHGbnCn9kNMmvfBVgZwQ8oExrkNTtMl/82dygLr7J7yfsi7uoGUbMmI3pfJ46kXqwfTQJZ/M3KlIkP7lOHDnYXLIVDfp2p+T5PLKp+opKKB6pCPj8nN9Sz3Vl86SdclUFB9b/hS/tDNTe3zcuQxUH18VSucq5ZFkznUjiUE6e38HKLjjlwEkH0s53nQvrab42Esdy+tcLgIPDmRA4O8efzjjaTG5fA0UOf3aeuRyMlAwRQwEHuXTKSq+ucydhYxQ5QYilTEZDL9On0kytaxTEWpNTY19qoj0IdvgY0bGZoqOeJumDVS6n8vMSYaX4xOX2qD75JPoMhIzrb5kXTItRRPHFN3JwIAfTpAOhHRocuA86nU6naipqamT3+epFi4H/U26oqiXjnNLh8PHxV/wJQMVkpv6xceKypqOfXMdUzqT2wnpy+QDpCOX+X85PyVR8D746zcvI+UgnfL/eXqLt0Xl5D4hL0erIdmWzC5Im5b1Sb1w+eT8IT2FhITY/oTapb9pXGlcuO6pTv6MjD9Cp/L+glsTGk0up+uMG8Nu0oH9mrpPVy4+AIEgGD4ApjppYtIgysHzN2n5pJCRHXd8pihXRhncuHgdPDqSE57k89cv6bh4/pp+83t423xvhspVV1cjLCzMLk+6kk+my7b5JOf/y+eKuCOVRCkdsxxTPrmkTkw2xOuSaSNqm6+s/I0jdygejwfBwcF1ok7pdHjkyqNjLjOV5WQmHQnfGOd65XXTdflMCl2nz7iupK65TETg1K7pdKKMrE1jx8eJZCUbp/9las7ki/iql04bSjuShCiDQzkmPK0pV5/8LQr8cymj1+u1g8OysjLExsYiKiqqzkEROY9lYEb98np9T2lSAMbt4NfgjLwVWTop02f0t5zADcHr9aKwsNCYMqkPNTU12LZtG3bv3l0vsTRWJllO9suUPgHqpqi4QUrHJSMbk2ORMkjHyNswtcWX/A1tBvJUhEkHPDVAbZj6aXL0Ms9O5eXzB7TikW1zXfCH87hzrq6u9nngkfTFn87mEbxMrUg9Uz2mMib9UL/lZr4cV5MzlY4ZgM8JO3kPXxnxfsgfPg50P5eJk4K/cecwyS0jdl6WyphkpoduacxNaSh+Ta5GJPiYEbnL1RCBB1w8svdn2wSZUeD94Trjjp3akbYt90q5Hmtra5Gfn49169ahoqLCThVyeeRYc51xgpV+gPdFrvxra2vrHMLxh99ELg0ZmSwjFc/LcWOiTVNT/Xl5eZg7dy7Ky8v9TmI5kF6vF99//z0mTpyIG264ASdOnDAaX2Ov+YOcRNLYpRGSnJQm4Y7K32DL/nKSkL/lBOdGynXHUzk8CuMyS7Lkk4wcp9y4NE0kfp2vzuS9Ug4+HpJA+UShtuSmJ91DE1j+5hExJw2uU3Iw0j7kuNGYkjx8/0ISDe+b7D+XQTo3SQTScVH73DZlm/7sXepC2jQnbHnAwERc3G742JnsgtuzaXx4f2T0zfvDV/dkC+RfuD5NqwveZ/5WaVoxSJnr6yuXi9sol4fLxHXIx5HKcZtcv349Dh06hLCwMJ97eTkuq/QrJiIj0pVEJHXdGJzx73PhRilJSDq42tpauN1u/PDDD3jzzTdRVlZWx6FVVlZi+fLlKCoq8rv6oOU43XP8+HG89NJLuOyyy5Camor9+/c3Wn6TIv1FRVReThLAN+8uB0s6amrDNKFlJMPz91K3fNLJurhjJ2dHZei0FJef+iBlk3sHvH3eL38OQgYPdJ1+/Dlh3g6f6CSniVzl25npHh65S9klUctARhK6vEc6fE5Esl+S6GVQQOMiD0Vw58H7ZJKX9MBThTSOpCu6xu2Y697kiAHUcfLSIZmclGke8Hql/PxeU1DE25ZBhSRc4JfX5Msgjf42ZQykTRDpcIfub4UtbU/KzseCBzrcrgCguLgYH3/8MYKCghASElJnrnOb4fOsurq6zp4f6YaTHV/90w9PrTcGv3pD359DMS31eXl/BkSMm5WVhalTp+LgwYM499xz0a1btzokdOLECXsw/XWWp1lWr16NwsJCXH311XjuueeQl5dXb0rNn9M7HX3wAakvBSJXCdzx88/439zgePqIjpLyPlCumO6XEZ7J+VAqiuf5abLw912R/iUx8L7TKlQee+aRJYA6+1H8OQJOenyi+eTcS2vw1cufYl7ecgxtcTniO+yHx7sbEZtLUXx2CsYiG//Oi0HvvW78q9oFt1WOkUP74LO2bjiOpODF8mWYGZSA8OIY/HgoCp6zLkLNN2sQPzEVl/w8C1+NPR/N3SEI7rEIwc+chezYfNx+RR+kJXb2mdScrLlOSKcmAuP/S4fGx53KVVVV1UnL0Pwx2ZgpDWuah1IuGjdJLpK8uC1TGYJcuXNnarJvDn864tfJvoFfgh9+XJfKyKPEfB5JfVAf+GekY7lHxgmP10Pt8e8K4uPJdSf/l59xOSmgPHnyJKqqqpCenu5DSiEhIXVWh1z3ct5RG5zUTNcodcxTig3hN50W44PlDyalSgdHnSgoKMAzzzyDoqIihIWFoaqqqo7TLS0txcGDB32ciz8ZSBEbN27ERRddhLS0NERGRtorInmfXNYCDb/xmIP6xSNnOkUi9SYdMt0vHbZ0RhR5VldXA/jlzDxNINO+CScYSXrUPhkbkVR1dTUOHz6M9PR0hIaG+jgw+byIjAY5YfCNYf7FX7wc1z2fpDyak4bNJ4xlWSioqsWffixDfOpxHP1XHvqebIKvJ3fERVVASOwCfLa4CR7fU4zJMVH4bntbnJ1RiFlf/4DukfF4+dhy3FVZjprE7tjnbY37Yz/Esc278NTiMoQtzcGqMTUYG5SIN9YexhBXOI63LMSm15dgaJchSBtZ96FKaQNkRzJ9xO2BOyweCMixdzgcCA0N9Tl2ylewZB+mSFPKxus1pcD8BQ2moIuXl/LK6yQTBR7ydB93iHKsqc/UV94/7vw5WZv6JR022StvQ/oDGQBIe5c+je/l8fs5uH6kn/A3V2pqarB7925UV1cjNTXVrpve48fb4vNJ+kyerZBBCN3L9U82LF855A9nJC3GI1N+Daj7qg3qXHFxMV599VUEBwfjj3/8I8LCwhAeHu7DuLW1tSguLkZMTAzCw8PrREhcGdRmeXk5tm7divbt28PlciE8PBzl5eUNkiLvR0OQBsMnBo/SZKRCf/OJxfOlPCKRRsM/r6qqwvLlyzF9+nQUFxfXkdnr9eLIkSMoKirycYSyHjJEj8eDvLw8PPjggzhy5EgdZ8mjUS6r7C/VB9T9PhJ5n/zbFNn6sx3LsuB1VCK4yTcIzg3GschvcKJvBdL2rMWe2DVofpsbn3yyF70HHkFylwp4Ug+jJrkQUduvwXpXOwzqdC+O9Po7Ms+dhZzQFcg9qxTWriBc3LEAF1SNx+CLOuNk3D7EZC3Due8fxflfzEUzdxGauUJ8dMhtVQYHvO8mBy3roH5RikLWZRo7DklmdA9/hxaNNb8mV9q8fpk64+1zW5PEb7I17sD5bz5XTOMudUnpxurq6jrBq3TIUucm5y1Jjf6XdUpi5mNP9fH9IpmyMpEfD/i43mXKyuPxID8/H7W1tYiLi/PZw+FZBb5vQuNXXV1dJzXL5eX94jbH62zsyuU3kYvJ8Zomj8mAyDBIeTNnzsSqVavw5z//GZGRkSguLraZmE+4Q4cOITw83I6mTUtaasvhcKCoqAhHjx5FUlJSHYJrbN/8OQRTv/mkkstTPqHkXgI/QUV9lVGYfIkfGc3Bgwfx9NNP46WXXsLOnTvtPhKRVFVV4f3338eRI0d8UgQyeuaTNT8/H0FBQYiMjKwzqeSpMBMRclKRREL3cPKQhOVvHORvui86ysI/OuxAh9hE9Ls2Hocv/A67Q0qxd/cy7M9MQN/zhqBVl1Tszj6MmzvkoWjV9cgIew/hV36D8knlOJizBm+81xXBSWXIe2oSXM51qLw4HN9neNDiq1rk3p6LG9eWwbWzGosuKsVZbQ4jJPygj6352zCXTsRkhzx6l/OExttExlwHMpLnqyBuVzJVxcvzuSrnlgxypIOi+mQ0Lh2rHFs+P3gdvB1/+4oAUFFRgbfffhvz58/3CWq4U+U/Jnm4zP5WXPQ/JxqaT/IdfUTc8sfUbzpWLOXg/eZt1tTUIDc3FyEhIWjSpInx2TROIGVlZdi1axeys7N96pX64OCrGdN3xTQGATkt1hjw1QwfmOrqanz66af4+uuv8fTTT6Njx45wu90oLy/H+++/j5KSEh9numrVKmO0wDfmgF+WmIWFhQgJCfH5zmd/qS6T4cr/5e/6dGMaCH+rGBnJSYckHTyhqqoKixYtQlxcHDIyMnw26yjSKS8vx5o1a+p8fwafNDIt8tVXX8HtdiMkJMT+Hne5ESv7APh+Rwff5JQrGu4YTcZtShHIH15PbYkXC/ak4ZbSdKCsC877KR4RZx9HbssR2LlvL5xFd2Hp9itQtXI3rME/I2LIHPSq6oahX8fjjq+/wwM/voQufZah6/CTWBA3H4uihyJhbzYqnbPx+rdrENxqP47ffhEevWkcTuzehe6eTggvLfUZax5YSEcpx9XrPfVAbVFRkU8wQX3lOpYnhaTjNDl8uo90ycdZBjD8mqk+PsekHZrmAR9rf4RF9dBmsiRF+s03tU1zyrIs5Obm4ttvv8XmzZvt+2ilUlVVhdzcXBQXFwPwfe0+X5HwFRufF5yESR6+2uH6kKlm+ZyMnENcd7Q64XZAnzudTnvvk14ae+TIEXTo0MFOkXJ5eP1VVVU4cuQInnzySWzatAler9d+6JKTkengjCnzdDo+P+ArFw5pZNIxe71ebN++Hdu3b8ejjz6Ks846CxUVFdizZw+CgoLQpUsXRERE2BOlsrISR44cQWhoqP1eKlOKiX7X1NTgwIEDtgy1tbWoqKjwyU02BtKp8rZkFMPTC9xg5aTmE8VkxHzy88iBOxSPx4PKykp8++23GDFihK1nMlKSvaysDNXV1T7pFTlReT+qqqqwadMmpKWlITQ01CZ2yvNLkuNREHeG5Ixqa2tx4sQJ7Ny5EyUlJXYbx44dM25Cy6U9f7CO9MHl8Hg8qPG6kGolY+4Tu7A96x1kbSxD/t5Q3L+pA0Z1aw9H0ksYuON5ZF9dicVvPYYfehRhnzsYmB+He2a1QGyPS/Cn3L64/ssTiL+sOS442hn5W87H1MEz0N3TA923dUCnD7ph2tdfoM2GWJyszcTBLnF1AhLuTDm406H+bd++HStWrDA+lyPJiD9jJB0TJxz5IB6fgzYR/z+HLp2cnKv+SIuIkR+35n3jbXFb4cTFdUJ1yOdZuOPjdck5sG3bNuTl5SE4ONinvzU1NSguLsY//vEPfPTRR3Zb/rIdfG5IAjUFm9Q+rT5k/3hZmaLiOiddcJ3KecEP2ZSVlWHz5s1ISUmx9UXfLUPlSWe1tbVYv349PB4PunTpYutIBpgyCOLjblpJNwa/akNfkoR0VDwK4h2VRud2u1FSUoLLLrsMHTt2BACUlZVh3bp1aNKkCfr06eNzSqG0tBRlZWXIzMxEaGhonXa5IezcuRPh4eGIjo62J0NVVRWysrLQt2/f0+6vNDjA9/UJvO+8zyajpHKmyMAf+MTl0VZRURFcLhcyMzNRVVWF6Ohon7r4srqqqso2FjlhSS6Xy4UTJ06gpKQEqampxu9ckXrhY01RI5HH7t278d1336G8vBwxMTFo3bo1brrpJqxbtw4rV67EXXfdZU8KqoO/NqSqqsr4WpS6K6cg7OkyBuUFX6B1Vm+0GVmNtMU5iC7fhYGV5+DiK1Nx7aAynFybjZDWC9C/2THsGHgO/p1ThtqzZ2DRtYOxeWE6jv+rCCUH/oCdf1iIyVldcbRgJdr84SZ83WwDyhZPR+z6LmjZYQBmt9mAIRsvRm3zU7JKPXF7568N4RHiunXrkJ+fj+HDh/usHHnq0ul0+rz0k69u5DjQ59yRh4SE+BzAcDqd9mEQ0rlMp0li4c64trYW1dXV2LdvH1atWoW8vDz069cPvXv3RkRERJ3oX9bHZecRP409d2a8j1SGB0i8nuDgYLRt29bHRil99NNPP+GZZ57xmTemeWgiEtkXeXCGg4iDr/LoHq5H/sPJheY4rbr4C0J5PWVlZXC73YiNjbXfQk12QvojWdxuN1avXo2goCDExsbWGwjINyKQ3rmMfP43hF/1VmSCaTXCheNGYtosOnToEOLi4tC+fXs7/bJx40YcPHgQl1xyCVq0aGHX53K5UFJSgpKSEnTr1q3Oe6Y4iouLcfvtt+Pqq69GWlqa3XZZWRlKSkqQkZHRoDM3GRjgu3zk6QcZAcgB4Z9LI5aRFNXHjUvqmhzIjh07UFVVheDgYGRmZiItLc2nnNPpRFhYGFwuF9xud52TORy0Ili1ahUOHz6Mc889t04qJCgoyI6WaFwLCwtRUVGBqqoq7N27F5s2bcK6deuwd+9e9O/fH127dsXIkSORmJiIqqoqeDwezJ49GzExMfbeGfWRR6dypcX1Lm2tNtyLvU2XYOdDExFZ2gpBG9/DfTem4dk3U/BVzido1cGNLV8/jLHZ+zFzVFukvzMaMw9VImTCYaQHHUfc7K8wvPocvHXRZegV+znyVpbh3+u+x2VXXY3NG59D58Qn4Ny2B98EjYIn7lm8PC8MkcNcPhvJ8pkCaUvSgTocDnslR4RK40NfqEb1yhUy9Z+ngskW3W435s+fjwMHDuCmm25CXFycz7jz+qSM3K6l7Xk8HpSXl+Obb77BRx99hHHjxuHcc88FABw/fhwpKSn2VwFQP6XtmlYNMjVF4yv3Mbg8vD8nT56Ex+OxU198fq1btw4DBw5E9+7dffrGSZDDNH5SR5IASTcyFcb7IvdUeRtyLGh8uE04nU47OKSj6E2bNrXTZDQvqT6SsaioCDt37kT//v3t1ytJYpVBoin1KP1fY3DaKxdJJiZBeSqIszl1nJzS2rVr0aVLF1sxlmUhKysLVVVV6Nq1q604isj27duHgwcPom3btnXqoyjM6z118uzAgQOIiIhAWVkZgoKCEB4ejpycHMTExCApKclHdpKfjI8TBJ+8PCoAfA1ITiLuuOsbLDnpeF18VcGjVuCXJ81zcnJQUVGBdevWITIy0l72UqTHU3Jy5eiv/0eOHEFcXBzatWtnGxxfhfJ7q6qq8MQTT2Dv3r0IDQ2F1+tF165dcfPNNwMA9u/fj4SEBDRr1swmucLCQhw5cgSjRo2y9Uh99nhOPUuzefNmvP7667j++uvRs2dPn7QcN3SSO7wmEv3+3QsRKS/BqoxB7OB07A+OwYjj32Hrw9G455M/4h97nPhH5444570S9D6ZgPn9piHpcAJundsaCaldsaCiAwbUvo+7/jQMb3x9ED2D/ohx73+OrObJWNHvOoweOBZdnOXo0K0HNq88iog9S7CvsjlycnJgWRYyMjLQrVs3JCYm+jh+blfSidABDCJSfmSc24p0YqSzsLAwm4xo3A8dOoQXX3wR06ZNs+ugMSSdSfugNCbZLn1Gc5Wc2ty5c/Hhhx/i8ccfR8+ePe0AiJeXjlOuVKRTlQEp758pgKXrRKQbN25ETU0NvvvuO4wdOxbh4eFwOp2orKzEmjVr0KlTJzuNTuDykk3LY/ykNz6O1Be5kU/jKcdL9t2kH/6bjuuHhITYc3zv3r04fvw4kpOTERQUhOLiYnuMgoKCfFLH/Fsqa2trUVRUhPz8fPTr1w9BQUHIy8tDZGQkmjRpAss6tbLlqyU5v0gvpu+gaQinRS6S0bkj5oqUUTmPtKhMUFAQJk6ciIiICNvQS0tLsWPHDiQmJqJv37728q+yshIOhwP79++H1+tFixYt7HZMg3Xy5Ek0adIELVq0wIkTJ+D1elFRUYEdO3YgJSUFsbGxPpPdn/xcdtlnt9sNj8djH4kuLCxEbGysz/MH8gw+b4Pa4ZOPyvHUlYy0+HU6ZVJYWIh58+bhkksu8ZmYXPaamhpUVFTYb2Xmy12uA7fbjc2bN2Po0KFo1qxZndNeUl+hoaG48847cezYMURHR6NZs2Zo2rQpLMvC1KlTUVpaittuu82nL3l5edi+fbtdjuSkCev1ehEbG4vDhw/bToG/MUC+xdXpdKIosgzfTV6PyZtOIietG/b9cA4GtdiDdysPoMvKq/DsyVocH74YSB2EuesWwDX6S8SdVYKQVefhT82uRZVnGx4c1wvd3tqHT75+DS3H34M5c5Ow5FAfVFWuQOyxP+GsxC04O3IrPt07FK6padi45w1UfJmF8vJyDBs2DMuWLQMAtGzZEldddZWd4zYFLaQ/epZLRrw0XyzLwsGDB3H48GH069fPnismZ04/hYWFyM/PR2JiIiIjI31sqqamBqGhoT46l+k2Occprbx9+3Z8/PHHuP/++9GjRw8fuya55CqDH2HnY0b38vkmHRe3N5pPFM3Tb7KlPn36IDc3F5s2bcK5555rb3qXlpZi4MCBdnsyQOMb21wGPnf4fKY66B7+5Wh8VUnl5N4w7z+NIbVbXV2N4uJi7NixAwDQu3dvZGVl4YUXXsCRI0fQvHlzhIaGIigoyE4X87Q37cvQj2VZPnucc+bMwYIFC5CSkoI77rgDCQkJPoGEJBe5cDCteOvDaaXFpEPmZMEHgcDL0P1c6KioKJ8BPXbsGDZt2oSqqiq8++67OHnyJLZv347g4GAkJSUhKyurTj2WZaG0tBS5ublIS0tDWFgYioqKEB4ejvDwcERERKCyshIlJSVYvXo12rVrZz8/w2U2/c/7ypf6tDqifZ+tW7di+fLluPrqq5GYmOhjmFxHfAJy5y71xvtYXV1tH0DguqKIqby8HCdOnEBCQgJGjx5ty0t5dQB2KopPDNOYUWph8+bNGDZsWJ0X1PHImRNOixYtbMJ3u92ora3F8ePHkZWVhZtvvhldunSx+2JZp17HU15ejri4OB8S57pv1aoVLrnkEuTm5qJz584+bcq0BAA4q4NRnn0uVrl2o9bbDqP378NjMS0QFVqNH1vMhSeoGCPDB+LAgb+jpuocpHzsRM/CcGxdV4lHHdV48uj5wN4jWNavCn84Pxl7n67C2UMXoCBkP9odi8C812ehd+wa/NO6GZknNmBQeBD633Qz1kbMwv79+/HYY4/ZJ5O+/vprPP7445g6dSr69+/vY6uk59raWrRu3RpNmjTxmdzcDslp7d27F/fffz/uueceTJw40X7dPvDLCpbudblcKC0tRUJCAsLCwlBZWYlVq1Zh/fr16NixI0aMGFHHJrkt8GwDXaOxmT17Ns4991x7JUnt04O30t4l0VCdclVmWpnIuWBa/VNaGAAmTZqE5cuX4/PPP8c555wDh8Nhnx5r2bKlTax077FjxxAZGYm4uDg7tUk2xlfQUhYpryQNCsZKS0uxc+dOHD9+HIMGDUJycrJP4ECBFAD7OZ3i4mJ88cUX+OSTT5Ceno62bdvaB5heeuklm6hmz56NrKwsLF26FL1790ZISIh9eCE4OBgJCQm27EVFRfB6vXj99dcRHx+P1NRU7Nu3D2VlZWjatGmdVK6J4Ele7pcag0aTiylHy6/x9Is0HlI8X3ZzwclQli1bhpycHCQlJeH48eOYPHkybr31ViQmJiIoKAhPPPEEiouL0aJFC/vES15eHp566ils27YNH3/8MZo3b47PP/8cpaWlNmOXlZVh3759OHToEG644QYfOWhy0vJ+9+7d+OabbzB48GCcc845xgebHA4HYmJi4PF4sGbNGrz88su48sorERcXh6qqKhw6dAiRkZF2+o1vsnKnzCM9OmpIhr9z505UVVUhJiYGnTt3RnR0tE1KZNT0qofa2loMGTIE8fHxPnqn10Rs2rQJlZWVtlMyESj9lJeXIzo6GpmZmT7OhmBa8ZBTo0iwpqYGWVlZcDqd6Nq1a510XHZ2NqKiorBkyRJ7PIcPH273ETg14caPH4/CwkL7qKp8NxjfzLSCa5DeMgzdfrgOnx1fj5+vzUdaUDZOdGuP3SUHkPD92dixcCV2Jx5AWI0XzUKGYZ2rO1KbHETqwSBcGvcNvutfi7KtB/H8gURUdFyB3NYH0CyhBv2WVOP86SNwx/LJOJF9COk9O2B981Lcti8VBQUFyMzMtMejbdu2uPvuu+F0OvHee++hT58+dY550umi5ORkhIWF2atJ+lyeLOzVqxdefPFFFBYWYs+ePfbhFxoLcooU2e/fvx/t2rVDZWUl/vKXv6C0tNQ+sj5w4ECbCPjKgK+cKAggeWpra7Fu3Trs2bMH06ZN8/nqW2qfomb5ZWh81cKvm/6XKTS6xv/n5cvLy7F27VqkpKSgY8eOKC0txWeffYbc3FwkJydj27ZtGDBgAMLDw+20o9vtxjfffINPP/0UgwYNwh133OHzihav14vdu3fD5XKhdevWsKxT7zPcvXs3wsLC0KFDB/uABdklPw4MnDqU9Pbbb2Pr1q1wu92YOXMmHn74YbRs2RKrV69G9+7dkZqaCrfbbROZx+PB2rVrMWfOHFRWVqJHjx5o2rQphg4dirCwMDidTqSmpiIqKgqjRo3CsmXLEB8fjzVr1qBp06b417/+hZKSEoSHh6NVq1a4/vrrER4ebj/K0bp1a1xxxRX417/+hR49eqBZs2Y+OjeRPM1b/nXfZ4xcZLRI4NEKOUwyMjpaR05AGhtF85TecblceO211zB48GCEhYXZnSkqKsLhw4fRpUsXhIeHo7q6GsePH8czzzyDpUuX4pFHHkFiYiKWLVuG5cuXo6KiApWVlWjatCnKy8vx3XffISQkBJmZmbYC+QsAgVOTaPbs2XjyySfxyCOP2BEQ9Z8iTppEZWVleP/999G8eXMMGTIEAPDzzz/j+eefR2JiIp577jnExMT4DFZ+fj5KSkoQERGBDz74ALm5ubjxxhvRqVMnuFwuZGVl4ZFHHrFXa7t378Zll12G6667DkDdkzXR0dFISUnB8OHD6yyxifi2bt1qO39yyDJCIYcWFBSEZs2a+Tx0KseUR810D1+NeTwebNiwAZZl2VEUGabb7cb333+PgoICfPbZZxg1ahRmzpyJ3bt3Y+rUqTZhWpaF0NBQ+91JfIOfxoyfjnGWO9HL0RVNW7yCsK3AuKXtEXxrJ/xzVQkiV/4JMVVvYFBEDJoei0F+j3Oxv+kMhC+9Bu47cnDdfi+uObAdF618FEuD8uFqsxyD88/BT1veQrOaNljc7AJEb3ke2Wt74fLxu1G2bxe2dOqDoJMu5OXloW/fvj7pFXK28fHxddJg9IBqQUEBfv75Z+zYsQOzZs1Cjx49kJ6ejoiICDsgcjgciI6ORkREBAYOHAjLsuzrlnXqGYaKigqEh4f7fFnV6tWrceLECbzyyivIyMjAhAkTMH36dJx77rn2Hg3p0ev11hk/HggAQGVlJWbPno327dsjJiYGJ06cQGVlpf2EeGRkpO0HZCbAtPLwt2Ln5f1FyeRLKHuQlZWFVq1aISoqCl27dsVrr72GtWvXon///tiwYYM9h+lRhtWrV2Px4sUoLCz0+dI4qreyshJLlizB2rVr8fzzz8PhcOC9995Dfn4+QkJCkJSUhGuuuQaVlZX44YcfsG3bNtx4441IS0uzZTxy5AiWLFmC5557DvHx8Xj66afx3HPPITMzEz/99BMGDx6MBx98EBUVFTh8+DB27tyJrVu32qcHHQ4HmjVrZssUHByMzZs3IyMjA0FBQQgLC0OTJk0wdOhQWJaF6dOnIyMjA9deey3i4uKwatUq7N27F127dkVoaCgyMjJw++232/txo0aNsv0I/woKuedEfkYeX24sGk0u/Aged2JyGcydDwB7w4kE5xv0PDorLy/HqlWr0L17d/tYI9VPn9MJpsLCQvzwww+YMWMGdu/ejX/84x8YMWIEVq9ejXfffRc33XQTpk2bhsOHD6N3794IDw/HN998g8ceewwRERG2kdJzMF9++SXOPfdc9OvXD5MmTcK///1vdOzY0YdYeFRJBPnjjz8iKysLb775JkJCQrB9+3a8/fbbmDRpEt58803k5eXZX+JTW3vq+xfuvPNOHDhwABdccAHatGmD0tJSvP3223jmmWcQERGB/Px8hIaG4vXXX0dISAjeeecd5OXl2fqkjTdytvT1AbRicLlcdr+eeuoppKen49lnn8ULL7yAAwcO1IlW5H5KXFwckpKSUFxcjJYtW9qrO0keMjdPqxeHw2Hv23Tr1s0n519dXY0jR44gOzsb/fv3x7PPPouEhAR07doV7733HkpKSnDixAmsXbsWo0ePRlRUlH0vyTp37lwsXrwY4eHhuOWWW5CRkQGPx4OQKmDYu4fx0TkjkNDpIVTe2ArvlUSidOnlGJ02A9uiP0fN+HKUl16KA2U/4vLjDnxxlxOxs2NxnvcE/n32c4j7bg56JxXjeEowcss/we5B8WhRGYElNeswqfgtVHfZjq82VeGdmt5YPuckDkw+DrfbjejoaFvvlmVh7dq1+Omnn3D77bfju+++Q+fOnZGSkgKv99RXP7z55ptISEhAcHAwPB4PNm3ahLKyMgwaNAhJSUl44403cOjQIbjdblxwwQUYN26cvbKOjIy0D7fMmjULXbp0QVJSEjp16gSn04ni4mIUFxcjOzsbN954I/r27Yt//OMfsCwLN954ox1U8eCOvySUxpLmxw8//ICtW7di8+bNSE9Pxx133IGKigq0bt0aYWFh6NGjBwYPHoyCggJUVVWhVatW9qqezxlOWJzceGqIy2RKz9BnlIrLzs5GXl4err32WgQFBaF58+bo1q0bVq1ahY4dOyI+Ph6tW7e27Xf37t14+eWX4XQ60bdvX0yePNl+biQoKAihoaE2sV9//fUICwvDxo0bkZ+fj3vuuQdRUVHYtGkT1q5di8WLFyMyMhKRkZF488038dhjj9kBXG5uLoYPH44OHTogODgYl19+OR5//HGkpqaif//+2LVrF3bs2IGlS5di/fr1aNOmDTweD44fP46goCAkJibixx9/xLBhw3D8+HHMnz8fN998s72/GxYWhoKCApSUlKC8vBzBwcGYMmUKmjdvDrfbjeTkZGzatAlOpxMDBgxAr169kJiYiN27d+Pw4cOIjY1FcHAwqqqqfOY0+XfKopD/oxUaX901Bqe958INhhsNlZFpFp5CkSdAqEN0Hj0vLw89e/ZEVFRUnZRNaWkpamtrsXr1aqxduxaHDx/G/v378cYbb2DkyJHYvn07/va3v2HKlCno2bMnZsyYga1bt2LIkCHo0qULNm7ciDFjxvhMnIqKCkybNg3r1q3DnDlz8PLLLyM7OxsdOnSwNwFlH4BfViAfffQR7r77brRr1w5Hjx7Fa6+9hgEDBqBTp05wu934+OOP4fF48MADDyA0NBRbt27F0aNHUVFRgZKSEgwfPhwRERH47rvvAPzyoFRUVJRNyocPH7ZTVHzCeTweFBUVYd26dSgsLMSOHTvsvY3a2lqsWLECVVVVePjhhxEZGYkPPvgAeXl5Ps9QAL8cuKBrTZo0we23347g4GCfb9Dk6U0aG75ZzXVUVFSErKwsTJkyxU65EBlmZWWhpqYGV111FRISElBTUwO32w2v12vrcNOmTYiLi8OoUaPslIFlWZg7dy5mzJiBq666CmvWrME777yDZ555Bh6PBxWhJZhxwzRssipwy6GxKF27Dzlr2iMo/m/YFdcShcf6Yt6rfeDp+Sluq3Vjp7cT3pu7GrM6xiA/tw/ioh9BWUERDqdH4payu7E8vTfOKtyBncviMLzTTTiR8wna3/Ujdi09iiVF2XDnXovq2l3Iy8uzx6qwsBCrVq3C3LlzMWrUKHz22WfIy8tDZWUlnnnmGWRmZuLgwYO499570aZNG9TW1uLhhx/GrbfeirS0NDgcDsyZMweHDx/GY489BofDgd27d8PtdvtM+IqKCrz88ssYOHAg+vXr53Nk9+DBgzh27BhGjRqFc845x14dT506Fc2bN/dxDDSGfB7z1IfL5UJYWBh++OEHBAUFYfjw4WjRogWaNm2KhIQEBAUF4dixY/j888+xYcMGOBwOREREYOTIkRgyZIgPWXA/IlcxtEeRm5uLFi1aICQkxCf9y+2eZKyursY333wDl8uFTp062cENzf0ZM2bA4Th1XJdewvrhhx+iqqoKl19+OcaNG4fY2FiUlZVh3rx5SEtLQ79+/bB371643W507twZlmVh27ZtSEtLsw/rdOnSBX/729+wa9cuPPHEE1iwYIGdeaFnu1atWoULLrgAERER8HpPHfZp3rw5pkyZgn379mHp0qV4+umn0bx5c9xyyy3o1KkTNm3ahB9++AGxsbF47LHH8Oqrr+KZZ57ByZMnccMNN6B169a2nXm9p56yDw0NtTfln3zySURERKBZs2bIzMxEamoqmjVrhujoaHsFHR0djeTkZKxZswYulwshISHIz8+Hx+NBfHw80tPTfTItPJCmNk9nBXNaX3PMHb50uLKcKVIhcBYkZe3duxf5+fk499xzfV4dT8jNzYXD4UDv3r0xdOhQbN68Ge+88w6GDBmClStX4uGHH8Yf//hHTJo0CeXl5TjnnHMwb948jBgxAnv27PGJ9sm4CwsLUVBQgL/+9a/45z//iZdeegnHjx/Hvffei9jYWL/yBwUFYceOHVi/fj2mTZuGnJwcfPHFF2jXrh3GjRuH1atXIycnB//+97/RpEkTTJgwAd27d0doaChOnjyJlJQUXHzxxcjNzcX8+fPRv39/OJ2nHm778ccf0bVrVwQHB+PEiRPIysrCmDFjUFlZiRMnTmDXrl1o3rw5WrVqhc8++wzt27dHVVUVNmzYgPHjx9vpxxMnTsDlciEuLs4+0RUcHIyysjJUVlaiWbNmdSJEMqaOHTsaj4ISMcuH+ug6rWh27NiB2NhYOz9N6SCHw4G5c+ciOjoaZ599tj0WP/30EwDg008/RdeuXdGiRQvk5+fbaVUA2Lt3LxYvXoy//OUv6NevH+Li4vDII4+gsrISwcHBCK22MHBBM1yYdxQn0zcgos8YNG32PoKHpmP3U03gGh2NKM8u5CWcjy+3n4Ogtmvx8oTvkLo8He7aXDw9JB5bDrfCW9dH4Kt3/4rjr43A5jldkBSzBxf//DX+lFyLXntKsL+bF7s7j0PN5F0IPtTJXl2Vlpbip59+Qm5uLq6++mq8+OKLuOmmm1BQUIDp06dj586d6NChA0aMGGFHjpWVlT57HUFBQVi7di169eqF5ORkVFdXo2/fvigtLUVBQQHi4+Phcrkwe/ZsdOzYEZMmTfJ5kaBlWdi3bx9qa2sxZcoUzJ8/H5s3b8bDDz+MjIwMnzEkZ8ydh1yl1tbWomfPnkhPT0dycjImTJhgOzj6it2PP/4YycnJePrppxEVFYVdu3bhr3/9KxYtWgSn04mhQ4di8ODB9nynzevc3FxERESgefPmKC8vx8cff4z58+djypQpuPjii23b40fgeTq4oKAAR48eRYcOHeyDIZZloW/fvpg1axaWLVuGHj164ODBg/j222+xf/9+HDp0CFOnTsX5559vv1nc7XZjw4YNaN++PXJycvDKK69gypQp9iGaoqIi2/dQhsDrPXUidcGCBfjxxx9xxx13ICgoCLNnz8a8efNQUVGBO++8007dLVmyBD179kTHjh3RpUsXOJ1OJCUloV27doiNjYXT6USPHj1w/fXXIzMzEz169MCf//xnfPLJJxgzZgwGDx5sr3JpDNu1a4e0tDSkpaXhqaeewsaNG9G8eXOb/Pl39pAu09LSMHXqVMycORPz5s3D0KFDER4ejrPOOgupqak+XzNO/pKvLs/YngtF1TzPzdNhBLk3wx2YjJo4waxcuRK1tbXo3bu3TxlCSUmJfYQuOjoaOTk5KC8vxzPPPIN169bhlltuwWWXXQan04nw8HAMHToUs2fPxkUXXYT27dsDAP7+97/jxRdftL+5LTQ0FADw7bffIiEhAfPnz8eDDz7oE3Xx/vF+UPQ0c+ZMLF68GFOmTMHkyZPhcrmwdu1axMXF4eWXX8aiRYswf/58ZGZmIiYmBqWlpXA4HFiwYAG+++47jBkzBmPHjgUA7NmzB5s3b8ZDDz0EADh48KC9GTlt2jQUFBRg8uTJSE9Px9atW5GdnY177rkHCxYswAsvvIDrrrsOKSkpOH78uH2ggU7ydOzYET/99BOmTZuGK664AsnJyT55Vf7MA9+kJQIhsuErTjnWtCJcuXIlMjIy0Lx5c3ufxOVy4cCBA9i8eTPuuece+zjsiRMnsHr1ang8HjRr1gz33HMPPvjgA+zdu9c+pltUVIRnnnkGI0eORO/eve12oqOj7f6VuoPw+p7BSBwLtOh8ADtXNEHIkDicu78VOmcGYUrsUjy/vxy7f34QR/M3wPJ2QULiAiSdHITItCK8/6UDtW1LccVlg7Htglq0f+8oMjocw6pnB2HNP/+OsQmjsDb7Uvz9dQsfnzcbzs5LENr5L/aJx5CQEHvfbfPmzSgvL8e8efNQUFCARx55BEuWLMH+/ftx8cUXw+k89UCc2+220zFBQUGorKxEWVkZEhMTfR6i/Oijj1BWVoY//elPcDqdWLNmDW699VbbQfJxOfvss/HYY4/h6NGj+PTTT/HQQw/5PK/E8+ryhB6fnzTfCwsLkZuba6+QSKaysjLMmDEDJSUluPPOO+05FR4ejqioKGzduhV/+MMf8Mknn8DhcGDQoEEoKSnB5s2bsX79ehw5cgRutxvXX389Vq1ahdLSUowaNQo7duxAcXExtmzZYh8IcblcqKiogNvtRmhoKJo0aYI9e/bg6NGjGDhwIKKiouw+JCcno2fPnjh06BAGDRqEJk2aoG3btmjfvj0++ugjuz56ldSWLVsQERGBN954A+Xl5ejXrx/OPfdc28+lpKQgMjLS7ntYWBimTJmCo0eP2pvzdGilSZMmyM3Nxe23327LRN+7Mnr0aNt5T5o0ySZaSneGh4fjD3/4gz2fOnXqhEcffdRuk3yl0+lEdHQ0OnfubK+MWrRogbS0NJv4efDHfZbT6UT//v1x9tlno7S0FEFBQQgODrZXr3wvjKcnaZ5zH9EYnNbKhRom8CWuKUcq83Q8YuL3l5eX46effkLr1q1tpyfrT09Px7XXXmsz/dChQ3HdddfB4/Hg5Zdftk92kSMcMWIE3nzzTRQUFOC8887Dzp078Ze//AUvvPAChg4dirZt2yI0NBQxMTH44osvEBsbiwcffBA333yzfcSYp/xIHlJ89+7dceutt2LlypW4++67MWrUKDvfmp+fj4ceegj9+/dHaGgopk6dihMnTuDIkSOIj49HQUEBtmzZgnvvvRd9+vTB4cOHcfz4cezZswe33nqrTYb0RoH33nsP48ePx7BhwxAbGwsAiImJwd13343U1FScd955+OGHH3DfffchPj4e3bt3R4sWLfD1119j+vTpCAkJwbZt25CRkYE//OEP6NGjh20sfIUpTyzJseZ7YPxZGR4oeL1eFBUV2am9qqoqOwqsrKxEnz59MGDAAHtDfu/evfYJKMqdN2vWDN988w0OHDiA1NRUrFq1CgkJCbjwwgsBwP4ahS5dutj7WoiKQ9iYLtiX8TQK3fFoN+Iowj/KRtOqDCR0XYF9Q+9DSpNXkLnyBI4dSkUnx2fIyOqA8nOcyH99JbanjEQ7x48oq1iBLpFlKJnvQtQPZ+H8O9ZhzY628CZ8h8qLL0TpiFno+pUbUW0vQMyOU6lDOupNeiMbbtWqFW677TYkJSWhR48eWLJkCV544QX07dsXPXr0gNfrRUZGBpo1a2brp7S0FJGRkfZELi8vx+bNm3HNNdcgNDTUtgke5FmWZes5LS0NMTExePjhhzF27FicffbZPntktF9RUVFhbw7zU158LtOqsqysDAMGDPDZn8vJycHixYtx5ZVXIjIy0g5EVq1ahV27duHBBx9Ev379sG3bNqxZswaDBg1CVlYWpk+fjiFDhuC+++7DO++8g8cffxwdOnTAXXfdhUWLFqGyshIffvgh1q9fj4iICFveiIgItGnTBhdccAFiY2PRrl07nHvuuTjvvPNs26MxmDBhgn30ukOHDsjMzMT69evhcrmwdetW5OTkYOHChYiMjMSoUaMwcOBAzJ49G7GxsRg2bJi9d+hyuXDhhRfaQQ7Zf4cOHfDkk0/C7XYjIiLC3h8eMmQIUlJS0KpVK9v3paen46mnnrKP/XJHLdPT0ofyBz95IBAXF4fx48cjPDzcxz9bluVzGtTkuy3r1Okvyszwuc39HQXQPK3pbz/MH05r5UJLs/pyqP4iJOokP5lBnYmKisKf//xntGrVyn5VBe+0w+FAjx49cPbZZ9ttpaam4qGHHrKVxWWgfYuxY8fabJ6UlISnnnoKs2fPxtdff42bb74ZycnJeOSRR9C5c2d07drVLs/b5oPDWTw2NhZ33nmn/W4sikJatGiBp556yt7I79OnD6ZNm4b169cjJSUFzzzzjH2CitJU+fn5aNKkCS666CLExsbaUWP//v3RoUMHxMbG2tepf7QP4/V6kZaWhmeffRY//PADQkJCbEdAx1Lj4uJw7733omvXroiOjgbg+yoSTjA0Pqb9MznWPIXC06Eul8uHoCm67tixI5544gnExcXZeiWC//Of/4yOHTvCsiwMHDgQGzduxNatW/H5559jzZo1Nknm5+fjm2++wSeffILa2lps3rwZ8fHxaN68OYpKc9CyzVA8UDICu4f+iKtXtMai7PfwkjsTrWfsQ2VwF4x8ZT6aPXIv/pZ4Ac67ci6S/7oWX2bshmt/CvoN2YFHw6PxyO5cLG99Dfp5T+Dne3/GkwNScU9eOUbcdy9+vqUThruOouXIcLQ8loSmTZuirKzsl1NrTicSExMxc+ZM+6WfTqcTzZo1w4QJEzB+/HhUVFTA5XKhoKAAF1xwgR0Q0eklmRkgEqAxa9KkCTZs2GDve9TU1KCkpARRUVGIioqyj8NfeOGF9t6i1+vF/v37sWDBArjdbqSmpmLgwIFo3bq1zyvb5QomPz8fCQkJtjOiz0NCQhASEuJz+ozmTpMmTZCRkYGtW7diz549mDx5sk089MAp7ds4HA5MmTIFiYmJqKmpwfr165GTk4P77rsPqamp9rfItmvXDh07drSj//T0dDz++ON1AlXLOvXc1WuvvebzdRHdunXDJZdcghdeeAFpaWkYNmwYRo8ejfj4eFjWqcMONO+47sPCwmzd89N0JLt8bxsdrODzKSEhoU5aj/sTshG6xn0p90FUxuVyITk52UdOPlf5XKR7qBw/Pk4nDHlZkscfQXF/3hAcViNpqKCgwM6f0zKKBKXcHvDLQ128jHzqmEfJnIycTqfPZh5XNtXPnSFXCo+eOcvzgeanIujBIypjWlXJqILa5vsR9OoaemiRL0Xp+635q+e5nihC4kdr6e3F3InzY9y8j3QftS+fBqdokpwcdyLcUHjfqK/bt2+332bAx476SL/5aS5q74033kBBQQEeffRR+z4eBdGYUJ+KiorsPDGNXVVVFWbPno2//e1vuOGGG3D99dejqKgI999/P/bs2YNLL70Uo0ePtpf2e/fswVvzPkKHqodw6aR1+GruC8jFxYhvfxJ/+qcLb/4pGNdUJWPmvh3o2mclDn3RAsdCr0XOga3Y3n0uIjoXYUxNIkIv64XsqQ60L3EguVcx/rp1A65t7kDvlLOw56P12N3MjXcGO7C0dAH2XBCFHxa/gNraWjz66KM+T2rzSQ78QuZ0oo9sgKeay8vL8cgjj2DcuHH2MdPy8nI8//zziIuLw8033wyn04nNmzfjww8/BAA0a9YMISEhyMjIwJD/96xTTU0N3nvvPXz77bdIS0vD0aNH7b209PR0jB8/HqmpqT5vB+c2QT+VlZV4+umnERsbi3vvvdeeK3RK8c4778SYMWNwxRVX2Pfv378f9913n/1mjG7duuHee+9FQkICHnnkEViWhYcffhihoaEoLi7GyZMn0a5dO7hcLmzZsgUfffQRLr30Unu/jstE88AU5XOQrsnx0z10DDwkJMQ+NCRPv9K4cacsyd7kyDlB8LlL4A6f+sR/kxwScny4PvjnXC6+DyoDBn8BMycZ06te5IKC3ilXHxq9cqGoCvjFMcolFFc+Rdn0P1+tEOlwJibnJxmTBpA/GS4NTKbm+ICTLNyxkxw8XUfgSqWJJCcedyD8Vdv8Pp42or/5K0x4WZnTJH3zAZerC25cMqXFHTk9AEVlOdlynRFZeb1ezJkzB1988QUeeeQRhIeH22/W5e3yPtBYkuwTJ07Erl27UFNTg5CQEJ9jqVSGxiI4ONg+zUL6IaLNyMjA3XffjbFjx9ptx8bG4uabb8bkyZN90gYJ4aHY+tpOfFq1EOs+q8Qf2jyLrJ934qIpQ/H2V6+hx7fBeKDzGjRvPQF/PwZEZEahRVkLHC7ah04FkxC7/AfEJf0Rzb7ORxDiUBq+GCtbV2JEQhVGLojF96vL8VG3DIQ1uwJ3pq9A2ZFbMNL7JzRt2hR79uypE9lyuye9EpFQH/lT7QAQGhqKtm3bIikpyR5vp9OJG2+8ETk5OXZf6ZmYI0eO2M/TtGjRwufY/5VXXonOnTvj5MmTiI6ORlxcHDp37uyzacttSdoVyRsaGoqjR4/aKSDqS0REBPr162efQCN7bdGiBZ588kns378fQUFBSE1NtbMR1157LWpra+03lcfFxSE+Pt7WW6dOnTBt2jR7FSezETIw4fbPy5FOaUz4qpAOspiCUDl+MhjiuuF+SPoGAunTRNz+fFd91/k1WScfP+kfJHFKH8S3LPytgGRdjUGjVy4lJSU+HeJMzZXJT67QQzqcFHgn6H+acJx1qT6+4SiX7Lxdfh9XFicnIi8eSZPh8Tb4ioy3z5XOj8hSf6kc/aaIFPiFqHiulfTHSYVHvXxlwqMp0hv/4Q93EiHW1NT4vKWWR18kM/WLcttr1qzBk08+idtvvx1jx4499QzJ/yMIPsn4RjLvi9vt9nnYklZ0dK9M/VD/ed+oHOmXVnTcBmTqobqiAote+AIv56ej5MYi/OmQhfe+3IFeQ5IR+/NWnJ9biibZnbBw6CbER5WhT9xN2OT4CfubfIt2c/pg7WVr4TlZg+Kss3Fk5WZMwgisjQ/F0JjWCB1Ugm+//BbrutyLzAwPii99AOM3tkW3ri+hZbgTJ0+eREZGhs87uwh8ZQf4RtOmCUx2R7bCx5WnVmhc+NzhAQONu5x7fMzk80omcqyoqEBpaSliY2PrfLU4jQkRAa+f2wq3aT6veSqR6qX++ovYuf7kfDG1J1chkvhNwRv3JdzP8RU6BQrSX0lClLLxemT99Bm3E+6e+fNInFx5JkXex30Y91XcTnlWhfeBy85XRQDQr18/NITTfuU+VyQXgAaRjpzScxIAfBwDd/DAL8rl0S93/jSx6CE1yehSRjnAdJ0bBSmTJjIvQ8rmg8eNWpIWT7XxCcW/olmukLgeJDlR+wRuOLwebjAkH9VN/5te9SLJis7oA6e+Lvarr75C27ZtMXLkSPt+7uS4jFxmTuA0ruR4eHlJ/DIqBOCjG24n3BlxQ7csCzVVDqz8vhYtwo5iX9RB1H42B1fnD0NVyVvomunEqxP/irZr/gZ3ogPbIq/Die9zEd69Fda8+zKapixE6EvAj54wRF9ciO5TWmDF09uxK3koLszw4u/uL3Dj2P4YXurAzlkerN7dAe+Ed8TTYV7EDW6Kpk2bwuv1+nyjIp8v/la+0m6pT/QwJgCfAEWmFk0rW962ybHz1aEpCqV6qW7ac5BzkqeRZVBIc407c27XkkylrDKQkYEj9YOTkMxAkJ3w7IGc17wsX+nwz/h+MYGTitQfJyeTH+FjTuXldT5H5biQPrhc3NZ4FoVsx0SiJvB6eHuyjPSv/tBocjEtDbmTpYbpc7mCkascup8rgJwiNwpeB1cAVwR3/DJaMC33ZA7VZJS8HTkgVBcZgGk1wEH3c4Phm3umDTLTCo0bCidokokbGu3zyAko9cQ3+MiYWrVqZe/fyIhXTga6l9Kg3HHyN8byvkr9yhSHyfkAdb8vhY+zxxuO6mGtUbQXiN70PT6eUIFMdxY6ZwRh3YsWClbOwVlJ12Do4Wh8WbUMfVeH4aFDO+B+/Hzs7pSAmHeux8iTLqxatAHJWX/CLserCHElYl/kLFy99Xo0vfV7TPvxc9zeay3KHKMxGE1hoQQuV5IxoOHjLu1Gyu/PAfH7ZDBB9/CXi3LS5TbOx5bX4S8Yk87WFPGbCIrbCjknTiiyDT4vAN+3d/D6ZJvcVrgtS51Ke+I+ReqbPxMibYvbPfdP3Ja5L+T64nPeZNN0nQd8sjyvj89ZOcbSN8oVCx9buaLmfZZjJA9kBZxcuFFTGoa/5oWvTLizp+U9GTd9ORSBkwZ3mnJlwx0cVxx3VDJi4BEggTtYbjxyYnBFyqiI95nLTfdK58k/IxnkAHHHS+3xvDOfNNywAN8ltHQmlvXLC/aoPh6ZcF0FBwfjuuuuw759++y6eXmTk6LDG3wi0Gf8N3/XnCzH65dOREaOvF6+92cF5ePssC/w2FEL/8oajbmZORh27hgk/nUH7kjMQmbFEhwPbYqdYZXYErcKx3qkoGfYQ0hvtxHOez7G6o5dcPuGWvwYHoPZuzfA2aIjerfcDLdzCCI9Jfh87RHEH+yJTZf3w9Fbt+CYw4mLxxwG0L6O/fhbTfDPeJ+kg5T95OW5DfHf8igxrcpJp3zc5ApQ2jBvV0b9poDS5OhM/SSYSE7+708u3j7/zZ2lXH2YiI1gCkh5Od6OTEVxXUqdSpvluue+gAcOMnDjkAEY9xd8X5XqJPnkmEl7koF1Q4HSGSUXbkTcwUlHxwebM6BkQSpL93LBTSkTqXypLBlpmMpT3abJBPgaHK+X/uanUfjKw7Ts5+3SvdxQTROS38sHn09wUxu8bR6tmQyLR0AkS3BwMNq1a2e/r4uTlmnFQqkPSQhSB7wO0/MU3GhNgYSpn9xuPB4PaqwIzK+JRV7GKjT/fiIeOLsvPl32T6Rsi0PksGtRsXsmEoaXImTvQtwRNwbefhvx5t43sP+egzh7Xy1Cux7Ce6kpaN8uGckhMVjSZAZ61MZgzdgKVF04BpW93kH5sAM4EH0E7aaG47yPtuFg7DgkM+ciU1UmWU32TkQpHTfXjQymZP0mp0pz0JR6kc6Cp8voXun8efRu+owTmhwzU6aD60OOt79gjmcLTBE+/22az7JuU8rNZMdcV3w8SB/cF1qW5bMPZfKTciyk75I+QWYPJJmaZONjRm3LgNqU/pIZGd4vma6rD6f14krZIAnIJzlXBJXly3VOLvJNsnzAyNHw5a00OB7dmliZYGJcbmSSPLgS5USU9Um5TRODExAnJ9OE5zKYXhhHslG90lHJFBt3Bjya4c6K/03gK065KSjJRhq5rIvGiMsi6zJFTXwlR3VKx0HpuFCnF8GJNZh7LA2hrjyM3LcSaT/VoOTiPPRs9wNG/3Aptn+yE5tveBL7N3yEVsHxaNmhMya4jsJz1nVYlBqJ0J9/RmZhDI4638WoK+9B3jv7kbVjBbI+ycEjw95AaWIiPlhdjA1NbkOz2PmYGN0dllX3+2148MFlNNmZKbiRBCHtlsDnIH0mUyH+yEqW4eTA7Z0HQ6Z0DtXBV8omp2jyHaa+SCfH7YiTuAxquC+S80r+LaN1SaomeWSwyceSB2imsZOBFv3mc8FEOv7GXgYM/EvCTP5U3i/9Cf9c9tdkP43Fae25UMf4gEsnbSIAMk6uZKqDO0N5kspknPVNNjlRuYGTLBx8YtL/NJn4yQx/xicdOTckStlwh8hllKkK0gk3KpJHbm6a8ufygIBJXybSN0Eu9ek+UzTJicWkZ+586DNJ3nIJT3/L6Jk/TyWdp7vKheP/uhjXDXga8zq+gPeXAd6OneHYdAHQLg87ovciLWQimlQ7kbQ3BCevjsHWqk1YHX8Ssc3zEHk0HONDQnHMuwU5TbKR8ufvsemRXBzbewgdEz7EG2V/xPWu15G3pRx/iPgXzjq7HSqC1iHG291HHimbafLy8eCOXk5kGWVyPXL7lnOK18dJn/8vAyE55+gaDxwlyfizNdl/fiLTpB/uN6RuTKTB/QK3Sa4TDm5j0rGaUoNcl3zO8eumyF6uVHhZvrcpA2auR+nvJAHLfstrvE3ql1xFcTuQb8SWdsH7SavrgK9cZEqGYNqMNhkPZ2m6j9dJHaH75FLW1CHpeEyGRfWaoiApq3TEPAqQhMX7bXLiPFLnBsXlob9N+uIycoOTdXPnzU++Ab4TxES4JufF6yPD5MYrnSH9zScf3xeiftA1mavmOuKTg+/T8VQr1yG153A44IwMx/jeo5GfHYk7thzEbY5X0b3wQmQWfIeow5WIPc+Nn5etQORn6bj6spvw3SfLEd18LZr2CUbqtn3YjU7Y0vUILhrbCg9+3B+z07Ow4J1q9LqqA7psrMC8H+Yg6kRznFvSHscn9sCqVrvxx+RQWEIX3Hlxh8zHgDs1k02bxshkoyYn6s+50r38ZCO3XenE+ErEnz3xNk2pLV4fB9kFd/A05jyNK/vij7S5ffJx4P00zS2uZ07CkshM80UGuTJw9kcAXF6eDZJjLFeQXE4TqfpL41uWVeekp+yX1CUfVznfTgenteciVwINled/+4tqqV5yPv6Y0WRYvKzJQcsJAJhPanBj5vLyaw2lB2Sf+YSRhkxy8LoJUgYuo+lUjZyg3GB4/ZKAeZRGxsydP/WFp3SkzrhuJQnzY5NcLm7MfI9Cns83OTfetpwsISVF6LViDt7M6IKfH9mNq39uh71BJ3BnpYWPCmtw4aGLsbFvONZuXoqw717Hzs6paJkdi+6hEWiVey1Sjy7CK57m+ODru3B0yhZ8d3Ij8nZ1RqfmH2FJqxoM6jAEK+Z2wkFvNoquq8Dl/4xF8BonqvqY7VLajxwXGTnLsTc5ECojVywy+JHXCPz0FtUpVzucGLkscuXB6+aBBP+cB2Jkr5JouVySFHk/TH2WspgcoSQq2Qa/VxKA6QADH0uT7rjcpjZ5n7n9S1uR886yfjkMI23DX8BHn/FVEw/KuO6lTmS9MovQGDSaXIC66RJ+TUZEvOPSWZtSNT7fKsiiF2mMsgyXjdqTSuHKMw0Kh4n9+T08ncMdNDck/kPXZaTodP5ymo0bK5edkw71g78pgerzF5VIwpWrMX/pLp7DlWQo65ZjJVcs0hhNhMKjfF6O6uUpP6lTe4wRhPJLPTg58WMUvtgC5y7vjb6fzMG3i3ph+b8O4ec//BXRmfdjwpU3Iey2rQhNjEOPsnX4eUEaMKgSh1JD8Mctq/Bh7+koTQ5HVUowbgnJQty996JtcCz2jt+N/CdewYV3V2LevCJE1MZiQ21ndHG0r0McfDz5OJLMPCgwrURkP+tziNKG5X3S4VEZ2b5M38q5yuc5r8fk/P3NN+5YpZ54vXyOSKfO+yH7ZfrMpBcuG2+T99vUBh8fPp9lG9wfSsLn+udyyNSfaQ+Ht0VZCj4+vH3um6geGUzw69xeuDwmfTZmcQH8ilfuy5dEyklOSpAThq7LiUidNS2HaWKanLMkKT6InFSkE+Ry83rlxOZ7THxSkIM3OWzpgLmeKM0jI1Wn01nngTAuL23qS8dEdfPVCN8f4jJwncolN9czlZP7Y1y//qIkUxBB+uPyyVfvcNlk3/w5MRmYAECVtxR7yr9Hx2wHDvVZhR3XPYWuBw5j44ooHAlLhfenzgjZtAeRw/cj3NsVxVmhKMy/EFaP1VhbcRKbosejW+9VeD4lFs8fLEGbrGPIPHE28nt8hbLUPPTYU45FA9tjeWoeEr+8EHO7bMBTTRqO4mSKxWQvpnQtv5/r0eRsTXNM2oHJMZtIC4Bx1SntQcJEXNxhSocn5ZFlpJ1JZy5Jtz69NCS7XIHw6zIzwMuY9qG5XKaTsfJeqTN/clKQJUlY+hI5T+Q4moIWk41IfdK4mV7R5Q+nveciUzV8sOkZF3KitLQjh0Z/W5Zlv2GZ7qNOUV0yEpJOUQ6clJUvxU2KpHLUH0kyMqo31SE3+fj9fLBJHnpzMl+l8ftJHi4zJw+qh09cAHW+v4HL09joQ5KRLMejI0nYckLQ+JvGhkfxtHLjz99wWahe/rZaKbNdF6Kw9lgrjFm9C6G5pVh06Aes35SN4LKOsIJKkJRTii5h38H96QfYd/4G9FycCevpZvg2eivy5h7CVZv2oFlwLB7Y3Q1X7Q/DwcunY3DGRqx4/TKM2XcMf3z4IQx5oQCVBz7EjGZHMTC8OYIRb+uMom++t2faj5TpH7n3ZopY6T7T64h4fdyeZEAhAw+CfJODbJPXy4M6mVGQqweZWqP5KFOz0rHKgIbXJ4MR3h7pUkbsPGDh89nfSoT8F8lsInD6nxM/L0Pzka41RE4ej8dns1yW56QrfRfZHicW6be4jzMFHDzQ4TYk7Yv3pzFo3Le+APaKhTtd+k3vpSIBubMjI+N5P6qLTiuYHL7sFNUvB62hycYdFsnJ84x8EhD8OTq5cuDP5Ui5TI6QBpecKj9NxuWmb+ujyUh6cjh8DyZw3doDylJTJIckBWkcpr7yiSXrMq3Q+FjwNrgeZBqMnq3g4ydtoj7Hw/vjqa1B08SWODq5Bp+3aAvHzJPYFnQR2jaZjPuOxiJm2CR0aF+F74PnoJvja8x1v42DRe/j2MbLEPFxLHqe48CK/sOQunI3ep4Xiujse7H+0W4oOz4Os0JHIGLNzwhtcgBnuT0YNWQBakZdgIrSs31slmThNix1b7ILqVM+t+rrv6k8L8vHTTpjPm9MqS5TtM/3TKhu/uJWSTBcVnrbtzziXx+pytUQ/5s7VCorZZZ64/WRD+A2y2UxkTuVkXtHXJ98hWVy5iSnfJ8il0mOA2+f2wWfP1RGEobsI7cJwHe/S/5wn2N6fKIhNPrFlfS1s9QAb5wMjF6kJx06KZuUz1MjDofD50lrHvXyPRzuNOVSm6JGbhTSIOm3dMb0GX/dCcnLCZEvfXnEQHXJVRjJTGV4eouOZpLhkUw08Wjjjr9qAkCdycl/04se+YqRPjMdGOD3Up+4Tvh7snjEyR+c5HXKVArJLyc2ffES6SwoKKhONMt1z5fjPCKXTru2FjhR5IYn9DgshxOOwhB4Y5MQXulAk9JcFCZXw6qpRlVhApJdhSgNDkZMfBSOuwFvkRfxrYpRczwIIaUOBIeF4LgjGukoRZEVBASHwll+DAVog0RXAapjilDsCkeslYDoKKdRnvqCDEkUpr0F6ZC4PfHx4jbK9SePbct3ivEx4a8+MUXrVKd0SGSTAOrMe/5TU1Njf0Mif80/9UP2VT7/Zgpq5DsBuR3zwzdcZ1y/nFC5vyHZpJMnPcl544+ASW/khzjJyMwCJwsaO6pLPhLBCYTvc8ttAzmf+dcX8BWTHG9ayXLb4TKSPCNGjEBDaDS5HDt2rI4jIudBSqGUD9+g486Q7iGioL9pVUJ18zSZPGLMJwBXKo+e5GTncpPj5ukiPiE5ZATIZQN8X/LH2+FRCx9Eri/+lls++Z1Op/3GYaonODjYloE7dxkpcuchf6gM9UtGr7LPkqD4qoPukQ6Vg09+TsQ82pJLcdP7nXgZHp3K1IzJicu/aTKSTdE9fNXN9UljbKqXnBiRo7/Vh0wP8snMr8s2uL1LQpDpaVO0yx0EP/7NgyTeH5m2lnLJfToedPH0sCQDyzr1LZkmZ89tiENG/dJJ84DJlPkwEbK0cT4feZtcJ9x5c936+5sHnSabkfOQrtFcM+mR+0t5go+3zX0PJxdJoDJ4I51xm5JvSuHBI2HUqFFoCKf9VmT6W75XjCuUHyPlQvINMlOEQHVxI+LfvsgnGd3L6/d4fN9zxQmBDIrLS5NfGiTdz1MAkuAo0uAnmWTaoD5nToPLycnlchnfWssNQTp17kDkZOETlxOsLCMjKe6w/I0pdzJUBx87STpyyW8iB1Nd3OakHrkM8jkq3j6NMR8fUxm+ypYyyMCK60umn2TfTQ6bOwOuEwl/dfFr1K6MmPlbxKVzkWPCV6dSj7J/puiYyyrnidQftz8ZaHCSk2klfp3bqQwSZZaBl+F6kNkO0zjxk5O8f/Iaf1aL99vkqLkOZKpdEhF/LZApYDKNF/kMaWPUnrxXpgF56l0GdaSnxuC0Xv9CSyu+cc+JgAyar0q4Ikgwr/eXLxfiBiUJyURQ/H9u4P4iOQA+L7CUDC8dtKnf1CZPzVEdJD+RgnS4XGauK0ksMpfNdcoPJ/B+00Shtw9zPQO+r3aRTsl0aovrnINPYhk5Uv/55OV64Do3OS1pvNz5mfTJ+8nHQq6Q6TpPXUqyMNkXQQYuVJcE15cMJrgzkk6QtytlN9UtAwK6JueYtCVut7Jv0ulIJ0Z18AieyspUNHdU3NZMDlHqn9clyU/aDidzLiO3I2l3khT5a3nInkwvf5VjSm2aTmXKF/lyPXDw+Sjl5LLKMZdjyyHtiY85n1u8f6aAUo6LDKikr2gIjSYX3mkT+0pBuMKlMgDfp3H5NzSaHBGPPLk8Mv9M9Uonw4/ZEvikN72Ij3/OB5XLzQ2WL10lGZmOD9LhAgD2W025wfmLLkxOnssi5ZdGQv9zIuWrCBkRSmfvzzZ4mxwmeXi/qG8m58CdlJyoJkco9cbrIDvifeb1+Kuf24xpJcXtg4+z7L9JR3LSy7rpb64XLpM/fdcXiEi5/K1a5Rzn90iikjKZ+sVJikf5XH+SKE39lAGayRmbTpKaAlLeRz6GfBUHmN867vV6fQJKTrxcFjneXH98HvK6eTlJtNIfSHD98wUBr49/ER/JYPKBsl7CGSUXGbnLyJOEkdG7yRAlw8vlMVD3oSu6V97DDcBEApwMyDjkdV63v/b4b75XQuV5ek4Sk+lkGm/L1BciKt6ulEvmREkvsi9c/3JseN9INn5NRtckrzwuLduX+zVSl/6cpGliyrE09Rnw3fMx1WvqjwTpVabTeD2S3Hkkz8uaCFpGltKZSjvgqzFZN7cbchYEf/2UcvLgSKY5pX5NwRp9LseMO0Tp8OU1WZ/8LXUkCUaSBS9rWXW/QIvrmO+9STsxkZi0W27jUufcPngZuW8tIfUvtwl4n2WmhPwg+WEecHCdSN/H6yCYslAN4bTSYrxBfpbbFEFwxdE1WY5OkFDEwJfGnJy8Xq/PVxFLZynBHRwnGPk5HyBprFSOR/WmeniOmOSjSUr10m++kV+fQRBMKxEZFUpHK+WrzxjkpOR5Vi4X6cm0oUigv3nUyB0w17l0FFJPplWJHBdyFP7grz5ph9zRyZUJyUtt1qdHGWSZCEbKJ52V/Myfs5J2w+/jqw+5IjSNF7c7nvaVZCBXACZ74zKYViHSeZoIykSq8nNupxIyCKNx5Xsb3Ja4rcvUlj8ykXPMtP/C2+d64SsRuUIyjZUcM6qT74vIz0gu0gf5Ix4Emsqa+soPHnFCbgwaTS5utxtBQUE+KRyCjBCIDPgpGlKeLMcJhJRNDokvNflSnTs5U2Qlo0TpzGQUQXLyc93ckORDfLw90xFc3kdu4PxJfLkPQO2bnp7n/eaTgbcP+D5HYnL+0qHRvhnVQ9flePLxlo5L6pnLK4lZjoXpmily5P3ggQdfifHyMhKTJEqQm7lcV6Y0kpyUpENJpAQZ5UtHLPvGr8lVHneoJjmkjqh//H8T5Jzg+iU9ymPGcnXK6zKRuew/XxX5m6N8BWhaVUsi4jLI5894wCr1zu2NBxKmNJ2cl6a5SjLIjAx35HLuU/v8BBzXpSmwkIE6H5v65psM0hqyTXlUmdtdQ2j0UWSFQqFQKBqLRj+hr1AoFApFY6HkolAoFIqAQ8lFoVAoFAGHkotCoVAoAg4lF4VCoVAEHEouCoVCoQg4lFwUCoVCEXAouSgUCoUi4FByUSgUCkXAoeSiUCgUioBDyUWhUCgUAYeSi0KhUCgCDiUXhUKhUAQcSi4KhUKhCDiUXBQKhUIRcCi5KBQKhSLgUHJRKBQKRcCh5KJQKBSKgEPJRaFQKBQBh5KLQqFQKAIOJReFQqFQBBxKLgqFQqEIOJRcFAqFQhFwKLkoFAqFIuBQclEoFApFwKHkolAoFIqAQ8lFoVAoFAGHkotCoVAoAg4lF4VCoVAEHEouCoVCoQg4lFwUCoVCEXAouSgUCoUi4FByUSgUCkXAoeSiUCgUioBDyUWhUCgUAYeSi0KhUCgCDiUXhUKhUAQcSi4KhUKhCDiUXBQKhUIRcCi5KBQKhSLgUHJRKBQKRcCh5KJQKBSKgEPJRaFQKBQBh5KLQqFQKAIOJReFQqFQBBxKLgqFQqEIOJRcFAqFQhFwKLkoFAqFIuBQclEoFApFwKHkolAoFIqAQ8lFoVAoFAGHkotCoVAoAg4lF4VCoVAEHEouCoVCoQg4lFwUCoVCEXAouSgUCoUi4FByUSgUCkXAoeSiUCgUioBDyUWhUCgUAYeSi0KhUCgCDiUXhUKhUAQcSi4KhUKhCDiUXBQKhUIRcCi5KBQKhSLgUHJRKBQKRcCh5KJQKBSKgEPJRaFQKBQBh5KLQqFQKAIOJReFQqFQBBxKLgqFQqEIOJRcFAqFQhFwKLkoFAqFIuBQclEoFApFwKHkolAoFIqAQ8lFoVAoFAGHkotCoVAoAg4lF4VCoVAEHEouCoVCoQg4lFwUCoVCEXAouSgUCoUi4FByUSgUCkXAoeSiUCgUioBDyUWhUCgUAYeSi0KhUCgCDiUXhUKhUAQcSi4KhUKhCDiUXBQKhUIRcCi5KBQKhSLgUHJRKBQKRcCh5KJQKBSKgEPJRaFQKBQBh5KLQqFQKAIOJReFQqFQBBxKLgqFQqEIOJRcFAqFQhFwKLkoFAqFIuBQclEoFApFwKHkolAoFIqAQ8lFoVAoFAGHkotCoVAoAg4lF4VCoVAEHEouCoVCoQg4lFwUCoVCEXAouSgUCoUi4FByUSgUCkXAoeSiUCgUioBDyUWhUCgUAYeSi0KhUCgCDiUXhUKhUAQcSi4KhUKhCDiUXBQKhUIRcCi5KBQKhSLgUHJRKBQKRcCh5KJQKBSKgEPJRaFQKBQBh5KLQqFQKAIOJReFQqFQBBxKLgpFA3j//ffhcDhw4MCB/7YoNoYMGYIhQ4b8t8VQKPxCyUVxxpGdnY3bb78d7du3R0REBCIiItCpUyfcdttt2LJly39bvP8JHDhwAA6Hw+cnOjoaPXr0wKuvvgqPx/PfFlGhOC04LMuy/ttCKP7/i7lz5+LSSy9FUFAQ/vCHP6B79+5wOp3YuXMnZs2ahYMHDyI7OxstW7b8b4vqFx6PBzU1NQgNDYXD4TgjbRw4cACtW7fG5ZdfjgsuuAAAUFxcjHnz5mHevHm455578Le//c0uT6uW5cuXnxF5FIrfCiUXxRnDvn370L17d6Snp2PJkiVITk72+by2thavv/46JkyYgBYtWvyXpPzfAJHL3/72N9xzzz32dcuy0KdPHxw5cgRHjhyxrweaXCoqKhARERGQuhQKQNNiijOI6dOno7y8HDNmzKhDLAAQFBSEO++80yaWLVu24JprrkGbNm0QFhaGpKQkXHfddSgoKPC575prrkGrVq3q1Pf444/XWVksWrQIAwYMQGxsLKKiopCZmYm//OUvPmVeeeUVdO7cGREREYiLi0OvXr3w8ccf25+b9ly+/vprjBkzBikpKQgNDUXbtm3x5JNP1klfDRkyBF26dMH27dsxdOhQREREIDU1FdOnT2+UDh0OBxITExEUFFRvOX/7QsuXL4fD4fAhIZJp/fr1GDRoECIiIuroRKH4rajfYhWK34C5c+ciIyMDffr0aVT5RYsWYf/+/bj22muRlJSErKwsvP3228jKysLq1atPOyWVlZWFsWPHolu3bnjiiScQGhqKvXv3YuXKlXaZd955B3feeScmT56Mu+66C263G1u2bMHPP/+MKVOm+K37/fffR1RUFP785z8jKioKS5cuxaOPPoqSkhKf9BUAFBYWYtSoUZg4cSIuueQSfPHFF7j//vvRtWtXjB492qdsRUUF8vPzAQAlJSWYP38+FixYgAcffPC0+t4QCgoKMHr0aFx22WW44oorkJiYGND6FQpYCsUZQHFxsQXAuuiii+p8VlhYaJ04ccL+qaiosCzLsn9zfPLJJxYAa8WKFfa1q6++2mrZsmWdso899pjFTfrFF1+0AFgnTpzwK+eFF15ode7cud6+zJgxwwJgZWdn29dMst50001WRESE5Xa77WuDBw+2AFgffvihfa2qqspKSkqyJk2aZF/Lzs62ABh/brnlFsvr9fq0NXjwYGvw4MH1ymhZlrVs2TILgLVs2bI6Mr355pv19luh+C3QtJjijKCkpAQAEBUVVeezIUOGICEhwf557bXXAADh4eF2Gbfbjfz8fPTt2xcAsGHDhtOWITY2FsCpFJbX6/Vb5vDhw1i7du1p1c1lLS0tRX5+PgYOHIiKigrs3LnTp2xUVBSuuOIK+/+QkBCcc8452L9/f516//jHP2LRokVYtGgRvvzyS9x2221466238Oc///m05GsIoaGhuPbaawNap0LBoeSiOCNo0qQJAKCsrKzOZ2+99RYWLVqEmTNn+lw/efIk7rrrLiQmJiI8PBwJCQlo3bo1gFMnp04Xl156Kfr3748bbrgBiYmJuOyyy/DZZ5/5EM3999+PqKgonHPOOWjXrh1uu+02n7SZP2RlZWHChAmIiYlBdHQ0EhISbAKRsqalpdVJ6cXFxaGwsLBOve3atcPw4cMxfPhwTJw4Ea+++ipuvfVWvPTSS9i6detp68AfUlNTERISErD6FAoJJRfFGUFMTAySk5Oxbdu2Op/16dMHw4cPR//+/X2uX3LJJXjnnXdw8803Y9asWVi4cCEWLFgAAD6E4G/vRW6mh4eHY8WKFVi8eDGuvPJKbNmyBZdeeinOP/98u2zHjh2xa9cu/Pvf/8aAAQPw5ZdfYsCAAXjsscf89q2oqAiDBw/G5s2b8cQTT2DOnDlYtGgRnnvuuTqyAoDL5TLWYzXyoOawYcMAACtWrPBbprE6IfCVl0JxJqDkojhjGDNmDPbu3Ys1a9Y0WLawsBBLlizBAw88gGnTpmHChAk4//zz0aZNmzpl4+LiUFRUVOf6wYMH61xzOp0YNmwYXnjhBWzfvh1PP/00li5dimXLltllIiMjcemll2LGjBk4dOgQxowZg6effhput9so6/Lly1FQUID3338fd911F8aOHYvhw4cjLi6uwX7+GtTW1gIwrwIJ1LbUi0knCsV/AkouijOG++67DxEREbjuuutw7NixOp/zyJ2iexnNv/TSS3Xua9u2LYqLi32e7s/NzcVXX33lU+7kyZN17u3RowcAoKqqCgDqHHMOCQlBp06dYFkWampqjP0yyVpdXY3XX3/dWP63Ys6cOQCA7t27+y3Ttm1bAL6rG4/Hg7fffvuMyKRQNAQ9iqw4Y2jXrh0+/vhjXH755cjMzLSf0LcsC9nZ2fj444/hdDqRlpaG6OhoDBo0CNOnT0dNTQ1SU1OxcOFCZGdn16n3sssuw/33348JEybgzjvvREVFBd544w20b9/eZ+P/iSeewIoVKzBmzBi0bNkSx48fx+uvv460tDQMGDAAADBixAgkJSWhf//+SExMxI4dO/Dqq69izJgx9r6RxLnnnou4uDhcffXVuPPOO+FwOPDRRx81Os1VHzZs2GDvRZWWlmLJkiX48ssvce6552LEiBF+7+vcuTP69u2LBx98ECdPnkR8fDz+/e9/26seheI/jv/iSTXF/xHs3bvXuuWWW6yMjAwrLCzMCg8Ptzp06GDdfPPN1qZNm+xyhw8ftiZMmGDFxsZaMTEx1sUXX2wdPXrUAmA99thjPnUuXLjQ6tKlixUSEmJlZmZaM2fOrHMUecmSJdaFF15opaSkWCEhIVZKSop1+eWXW7t377bLvPXWW9agQYOspk2bWqGhoVbbtm2te++91youLrbLmI75rly50urbt68VHh5upaSkWPfdd5/13XffGY/9mo46y+PUpqPIQUFBVps2bax7773XKi0t9blfHkW2LMvat2+fNXz4cCs0NNRKTEy0/vKXv1iLFi1qtEwKRSChr39RKBQKRcChey4KhUKhCDiUXBQKhUIRcCi5KBQKhSLgUHJRKBQKRcCh5KJQKBSKgEPJRaFQKBQBh5KLQqFQKAKORj+hr4/D/HpYlmXrz+FwBOx72KleOTaWZcHr9cKyLDgcDjidTp/PGlu3CVJ2h8Nht+fxeHz6Sb/5T33t0edUh9frtV8C6XQ669Thr+9SBqkL2Q7Xkal/vDyvn+uZ18X/99eerM+kb+q/1I2Um9qgv+l/ko+/SJPqoh/+P5fR1A7/3B/455ZlwePxwOPx2DL467vUK++z6R6TTZl06XK5fGyHl+Ey0Wf19VG2J/+W9sWv8x8+H/n4SPlMOjX11WTbAHzsoD5bM/knrnuTvpo3b27UEYe+/uU/hEARCuF0yJ6Mj0+eXyMPb/O39sffhPH3tz+ZpcNujHzSkcr6/LUjHSDVZSLG+uTzV5e8h//tb7zr042pLO9jffr2d09j6peymSDbb8w9Umf+5DERfaDnn6md+uyTytE13n8ZkPi73/R/Y+TzRyzStmTdcozqk9MEJZf/An6Lsdc3sPU5IpORyM9Mqwt/5UyEZWqH39uQo5H1mX78rSJ4e6fbLpVriHT81eXPUfJ6G5roJrkpUmyobn5vfU5KjqV0dvX1l8qY+tqQvhrSP/34+0I3qTt+rz975fZikqGhcTwdJy77YrKjxtq4P/n8kQLXh6m8aRz9lTN9/ltIWcnlDKMhJ3K6ddHvhqI23k59BuiPDPwRkKmuhiakacLXJ4+pPq/Xa1wl+NOtv0kjZahPbukIZIrK1GZDhMvrqa+t+hwNled6NKW2eF2yTq/X65Oe4TCNQ32O09///kjH1I5JJ9Q3XpbsgD6rz+k2lGbyR5z+bL0++Ux9bKjNxhKArLux880UnDSGNKkNmU73N6b+oORyhmFy4P6c/enWK+s3tVMfsZkiH1OOVrbJy5kmJJ+sPFfPnbPMETd20kjn0pjUh0k+2Y78m7dBcvPJWh9BmtrnbfubpPWl40wgHZr2dUztyXq4LusjDilHY5xnY/or96v8td1QwOCvPK+T+uqPQEz9b4gcTUGGv74QmUud+yMWfz7CpK/TSbk2VDcHl5X+Px0ouZxB+BvghlYU/uoxXfdHIA1N2Iais4YiFU4spjqlA6ZrZLBOp7MOOTXkrLiDkBOqvnSNqf7G6txESv7K10dWDTln2Q9/faG/ibRN5MLvlw68oT7UpxdTn+rrj+k+KSOXrzEOsT4SbIj05OrudMbWtNKVG+j+5KAyfLVo6nN98vtrg/6ur+767q2PuP3pq7FQcjmDMBmMv0jR5Cz5ff7qbMhpNmQU/srLNIUpt19fn7mjNKWNpF5kVFSfczXJUR/xmNqR5XgZf6sA+duUAjMRqtSLqT1/jq4+YjKt/kx1SMj65Tj5Szs1RieyrIkU6H9JLI0hl/r+luW5UzfZopSTy2CyD3/3+UuxShvhssh2TfoiNLSiNfXTnw00NG/9lVNy+R9CY4zen2E2NKH9GaQ/o21IJoLJOE2TsT7565t8p1O2Pv2ZdNKYe0z/N9Svxt7L4Y+wTWNlqrsx4y2jZtlGQ2PN9X26TkPKKturz3n6a6++8W+MPZv02lhCIqLjARXXr0nmxqycTe3KVLE/Yj0dAjXptzFzX+r7t9qEhJLLGYK/SdJQNC8Nhd/rzxBlmcakNvxF7adLSKZyJuI7nc1jf3KanM+vIVFTW6e7dyLHkcvqz8lLcjGtWPyNqb/PeZvcOTbkWE16pv7UF7X7CxBMjkk6bGnnpjH097fsh0k2iYZsvD4Ck3t7vE6ZLjLVVV8KriFd1Nc3f/1sTN/86cZ0b0OE1hgouZxhmPYlGnJk/gzMn4Pxd48/NIaUGmPQjZGdT1baZwFOPdzWmAnVmPy6nLCmuvz1j/+WBFgfkdVHTLysv/LcATVElCYHLuWT5CL7afpf/i0jatNKrr50oum+xvapPtlM+vMHk934G3dJJv5Ss6Z0oam++mDqGx+3hu4z6bIhJ8/vlQ+xmuTy12Zj7jHh/xS5SGP5b7TdkDOsL2qQ5RqbQmros8ZM7obqkXI35FR4Co4gnW1j+tCYso0ld1O06s8RSvhbZTYkD/+/sc7ZFDmbTl7VJ/Pp6Lqh6yYHyWU32UV9OjLpQd7r740KkoT8zXUusz+98d+UzvIXgMmj3aaUGsnUEGHUpxNTeTrU4a8Ppv1T6YdM7cmyp+s3f3fkwjt6Op21rFOvogB+OWFzpiGjPXmUtTHRTmOitPqu+zMikyE2pM+GIkCTE5R/c4PnMJ288Wf8jSU+Cd5Hf8RukrU+cjE5aJMDoN+mFKgsZ6qL2zx3dPxzUwqKyy9hIimTvhpa0TbkqEz3yj4S/D3vIvtHBGMiIX99lW2YbNdf2s/Ud5NN8zH2Nwa8Xn9j5G8cSQ/0uiUACA4ORnBwsHGcGtIntVEfCZv63Bj8rsjFsizU1tbaUUJQUFCjOuv1elFRUYHy8nI4nU5ERkYiPDz8jK5gTM6Ff9bQpJAD6c/Y6nO8jSGv+v6X7fr7jE98k2OVJMMniSmC9idTQ2ktk5z+9GEqV99K0l87pvuks5Lt1kcsplw8Ly9Ph/FncKTD8Nf/hlJcp5NukW00BH/9Ml3jMO3f0G9/feLlnkAAADUwSURBVKS+8FWOdNByLjV2TplSmgR/87o+IpE+wfQ5/e31elFdXY3y8nJ4PB5ERkaiSZMmCArydeem997xOkzv3JP989f/xuA/Qi71TWr5OWdkl8sFl8vl81lZWRmqq6sRFhaGqKgon8/9tV1ZWYnc3FwcPnwYYWFhSE9PR2hoaIP3/lqYJl9jIgP6v77BlJORYIpwOPw5eC5bQysb2Q5vizs2k0ymfjfk2BrjlP3111SGt2HKc9dXt0kf/lIGnDg56luZSZLiOvVnD/5IyB/Rmu73V4Y7F3/pKSnH/9fel/U2liPpfpKsfd8sy0s6qys7Gz2Yh/n/f2GAAaYfeqorZzK929r3fbsPiY8VpoM8x1nVcy9wFYAg6egcMkjGHkEqjAdh92MLTU2BAG+9DY1mbdDwYR9a8YM9Hz5a9403DB35FIxrDJImZrMZWq0W9vs9Go0GMpnMq/CY9pJrqh2KqimX36Ng/qnKxYWQy/Xc7XaYz+cYj8fY7/coFosoFArG8thut+j3+xiPxyiXy8hkMoEKYrfbodfr4cuXL/jll19QKpWQSCRQrVb/cOWiEauEIAXgux4mNKFZvS7rVIImCG1h5/ocVtmFBZ+i8F0P04dULEHzKb9risin7KQgdFnYGl722vnyKNqOc1sZuTb5aX3LsQdZ7kG0q43FvkcT8C7+4bumEDQFrskXXpf9aspVo3F73HZxiouftONTtHHZv8tx2YrxcPge3h8MBnh4eMDJyQnK5fIr3Ox5tmUE25LKxZ4LW7m48PTB/6rnogkfOQnz+RwPDw/48uULAODz589Ip9NIJpM4HA7YbDbo9Xpot9s4HA44OztDPB539gcAy+UST09PeHx8RL/fBwD0+32sViukUqlAvN8bOtOYJSikJO/xMa787BI62j12fuk9hC4FmKYcfTholn2YOdGe9/1uHykvf7f78jGGS9Bp/cpnOD672kpr26Z7eQ3AG+HgUiyacvHtxrdDYUFeKulG88hc97to2VbOmvdgz5tLKcn5dpULa+BaDxdtuXBgn1LB2LkLl9en9Sn5yu5LozPKwW63i5eXFxQKhVcKQzM4fDxu86eLToLkkwb/VOXis15txbJardDpdPBf//Vf+Pd//3ckk0nkcjl8+PABiUQCwHcvZDweo9frIZ/Pv3HrbGAYrd1uY71eG69lsVhgvV6HGkNYBeNaOJeFK+dFE9pBlq4c+36/x3a7xeFwQDwef+Uacx40K0TDnfev12vsdjucnJwYJexSLEHjCyJGe7wuxeMTYNpYNLdeE7i+uXC1rT0XJtQWNC++8cjvtiDxhZR8OPuu2XSjeVLaeGza8wk115y5hLFdFGMbP64wjo8OfN+1ObJ32WuJcb5r3otmYPj4xJ6z1WplIjjMtRAPbYOmb47tz/Yc2srm/xnlArjdS/l9u91iMBjg9vYWX79+xe3tLfL5PEajkcm/AN/DYrPZDLPZDNvt9lU/GlPt93sMh0OMx2Ok02lUq1UsFgvsdrs3z7twfw/4hKx2TVMwPgGlWZEAMJ/PMRgMsNvtUC6XUSgUXuHDPFY0GjXKx4UH8H2eh8Mh5vM58vk8EonEm1JHm9Flf5pCtufBFWbT2rPb5jMugeHqX1sLW0lpbUhBCbxNqvuEgtaf3ZeGJ+dXm0/+pikXOSZ7jK6+7Ht4XaMTF+7a9aBrmhfkyofY+PK7DHWRvu1wdxi85BxotGi35/KW5VrJ9fDRsvbdxkfO2WKxwGg0wnq9RiKRMNEbSRdyLu0/8XOF6+wxSr4M+2dxEv5XwmI+K3O322E0GuHu7g739/dYrVbGU6H1zHtXqxXm8zk2m43XSiFQSC6XS+RyOdTrdTw/P7+a8PcqEA2CiMXGy+WV2MRhPyef5Wuz2aDdbuOXX37BZrMxocR4PG7umUwmmM1mSCQSqFQqr0KJmmBerVZ4fn7GcDjE+fk5yuWyYWLfmOV1e1wa2PMQpGTkSwtB+RjFhYfGwD6hD8ApxMOMOQhXuz+tSELD2abnoFCsPX++UnAX3j6B7Xp34WS34erDvsboxGw2QzweR6VSeeVpyznU5s4GTclqOLt4VbPuXXLKJSNcPMV1ns/nmE6n2O/3SKVSxnOx+2ZEg5GaaDRqZIPLyJFeoFRIQfSqwf+VUmS5OLPZDE9PT0axVKtV9Ho9TKdTLJdLbDYbc/9iscBkMsF6vcbJyYl3rwoF73g8NtVlrKj4kYl6z9gIQfF1+zkfQ2lWOhnr9vYWf/vb37Df75HP53F1dWUIjgUN3W4XuVxOLVm0mXo6neL5+Rmj0QilUkktM/YJBU14SQaXXpBmSWmf7WthhPSPCDTfM0G4+cageR6bzQYAcHJy8sralnMmvSXtd3sMLsNE0qLMV8h5fI9yCTPvYelFu26351JS2+0W7XYbDw8PyOfzSCaTxjgFvhuoq9UK0WgUyWTS0L5v3Haf8ppP0GrzZ8+zvM+eB59is5XLYrEwyoJbMuz7d7sdVqsVut0uRqMRMpkMzs7OXs2BPQ/2u2zvvfC/Vi2m/bZerzEYDNBqtbBarVCr1RCNRnF7e4tut2s0rhSkVBacUC0+SM9kuVyaEBoZOChPE3YcQeE+TYlogsbXn4vZJaH1+308PT3h6ekJqVQKk8nE7AU6HH4LOT49PaFWq+H6+tqJM/BbKPHl5QWr1erVWLgOLkaQv8v+N5uNyQmR+fl7PB5HIpFQ806uOXmvgJNz6QqXaSEa2Z/drp2PCAoD2v2t12uMx2McDgfkcjlkMhn1Ptlf0P+2aON29W8reP4WpGA4V1xX4PuWASngfLi4FIdPaPuUy2q1wuPjI3755Rc0Gg1cXV2hWCwCgImK9Pt9JBIJ1Ot1ZLNZFZegSEjYMK8mkDXZYM8nnw3yrGiQL5dLJJNJpNNptWCHhslsNsP9/T06nQ7Ozs5Qq9VChXRd8J77f7dyeY/ml9cp/KfTKQ6HAxqNBqrVKrrdLpbLJfb7PRKJhDmDarfbYTqdYjqdIhaLvcodAK8XbLlcYrFYmLwBQ2vr9RqbzQbJZDL0Dn3NsrAFoT1eW+D4mCuob+0ziZHVc6PRCIfDwRCaxJl5qslkgkwmE5hgZbl3v99HKpVCMplUBboUCFTmzGVtt1us12us12ssl0vjgcZiMZRKJWQyGbPGpVLJhPBkexrzutZGu0dbD9cca4lql3Upxy5ffMZWCi4aWC6XeHl5wW63Q7PZfEWTLgEs+7B/t+9br9eIRCI4OTl5FZPn+263U5WjT2mT5hiWWS6XiEQiyGazyGazqpHgG4/r5Rqbax47nQ5eXl6QTqeNESPn+PHxEaVSCcVi8Y0S18ZozyW/2wrE5gP7d1/kwqZ1fpZ5NG1dttut2euXzWbfVLzK/qhc7+/vMRqNUKlUVEVE0BSoS1mGgd+lXOzOgrS7nEgS6W63Q7VaRaFQQCKRwM3NDabTKdLpNGq1mtlJTyG5Xq9RLBZVjQ3A1IC3Wi2Mx2PTB91JyXRhvRcXc8vrtgKSoFm/YeP1msDkPK7XawyHQywWCyQSCRSLRaRSKaOQJZFtNhtsNhtnIpKwXq/R6/Uwn88NM7qENtdxsVhgsVhgs9lgtVphsViYwov5fI7D4buHks1mEY/HsVwu0e12AXw/ukIWIFBRbTabV0UIsVjM6S255thWBLxPC8P5GEcTgHbimSdGaLkLLaS5WCzQarWw2WyQy+VQqVScXpktjIK8r+Vyiclkgmg0ilKphFgsplYRyblw0bTsY7vdYjKZoNVqod/vG0ONObloNPomvKfNqd2XxkeuebNxWq1WJqdIj11a7a1WC51OxygVl2DU+Np1r2s8UjFoStZ+xqdc5dglra1WKzNWeowaXXC9BoMBOp0ODoeDKczx5YpcYXvX2H3ww8rFJnz7s3afZAJatdwEVCgUMBwO0el0sFwucXFxgbOzMyQSCZOUGo1G2G63yGQyb4Qe+9hut3h5ecGXL19MHxTEXCQ7Lqvh6/tNszqkkPk9isNmfvtZOYfL5RLD4RCTyQQAkM1mkcvl3sSVie9ut3tTiWOPdzabYTAYYL//vok1m82aGL0miOfzOVqtFnq9HlarFVarlTmaYjweY7PZoFKp4OzszBgQ3ACWSqVweXn5pk0WYsxmM6TTaZRKJeNBAeH+G9w1l2Qu3yY4Gx855/TKFosFlsslVqvVq5LtdDqNVCplzntyKbLtdovRaGRCt7Iqkn3Jz4fDb0l3aeHKOSF+rVYLj4+PJnlLA00T5NpeEc273e12mEwmeHh4MPnRXC6HVCr1ira0M8+0tXIpFE2p2s8RZHJ7Pp8bL5ney3g8NrRMz8pea1+Y0eZVfneV9kt8tSiHFja06csOka3Xa8znc6xWK0QiESMHGQlgqB/AGwNis9kYPmKudT6fGxmoGQLS+JTjC2uIS3i3cnERCxHQFkRbLC5QOp1GPp9HPB43e1I2mw0KhQLi8TiGwyEOhwMGgwFeXl6wXq+RyWSQTqdNO7Jt7pd5enpCPB43C7ZcLg3h53I5Q2g+4vWNndU5ZGgKGI2AXW3ZilljOp+Vulwuzb4fhhFzudybsmEKJHpwLuWy3+8xmUwwmUzMKQYUHi7hvV6vMRqN0Ol0XnmFLJkkYzPsCQB3d3cYDAao1WqvmIPtbrdbs1m2VCoZIembSy2O7BpnUHxc3iNfLBDhHoPJZILBYGAMnkKhgEwmg1wuh2KxaEKAtiLji14eFZRGCwwH00vIZrPGi5OeB+mclX7fvn1DvV7H1dWVyZ3Rs9AqxaTC1ZQbQ0w3NzcYj8eoVqs4PT013jKNNamswigR13q51kV+pvCcTqdYrVaYTqfo9/toNBqIRqMmLE4DRVr5XH/ficJ2n5JubOVuPycVN+fdpcB4L42yxWKBk5MTJJNJTCYTPD8/YzqdIh6PG+OBEQGp2Em3xHO9XmMymWC5XCKdTmM0GuHbt2/I5XJm7Xx/jSzH+CMH/YZWLr5FJiJhBTPwPRxCQZhMJk2sv9PpGGbrdruYzWbY7/fo9/t4eHjAarVCOp02SWGGZShcKXDn87nZvcrNl7QmC4XCG+sewCtFIcMc9jjkfVzA3W6HfD7/6sTloPJObT5l25xXCgRbGDK02Ov1kMvlkE6nkcvlXhGdzIOQCGUFi+xfWtOZTAbVavWVgtYYLhaLIZPJoFQqYbfbIZlMIh6P4+XlBd1u1yipSqWCXC5nPJrpdIpyuWwEoh1S2mw2mE6nODk5MSEynyXlUiRSUMpnpWXpsl5le1SWz8/PeHp6MvnCp6cnHA7fT4sAgPF4jFgsZqr2zs7OjIImSMuXNEzlbwvmzWaDfr+P0WhkjkJiSFhTWtxgNxwOUSgUsFwu0Wq1TMUkFZ5miUv85HrTk3x4eMBgMEChUMDFxQVOT09NrsjO9dlrYQtT373ad/sa16PX65mxsXLs4uICyWQSw+EQ2+0WhUIBuVzOhNeXy6UpCpKluezDLutmv1IZucKsUibN53MAQDqdRjabfVWlaYe9qCiZfC8UCqjX60YhzOdz5HI5U8TDnBf7kXKLPEgPez6fIxKJ4O7uDofDwRx9RfnrCvVLb19+DwvvVi7aZ1cCSrufwJABX/P5HC8vL4ZYlsslnp+fTTik1+thMBjg5OTEWG/L5RK9Xg8vLy+IRCKo1+uGuZbLJSqViiHC9XqNcrlsNLadl6ALOhgMMJ1OkclkUKlUkEwm38wDBcFisUC73Uan0zHFB9FoFNvt1ggB+Tyfk0rkcDjg5OTEWFWMly+XS+x2O5OrkOEuiQtLLev1OqrVKrLZrGEQhs1Y2l2pVJxWIoUICyzy+bzJhdjhP0mAqVQKp6enKBQKRtlsNhtzqF6xWEStVjMCdrFYYDAYGCHVbrex3W6Rz+fNGCmcaRVLK5DgCj/I9eS45DXbwvNZoPbzs9nMlHVms1kkk0njsVarVTQaDbOh9f7+Hrvd7o3XRRrY7/cmLMFCE41/mGvs9XomP8PEuQxf2TH51WplFAu9rEqlgs+fP5uQiBwjvRcAr8KnXLOXlxe0223EYjGcnZ2hWq2aGL4tKO159CkU6SFpc+5aE3rZ3W4X0WgUFxcXSKfT6Pf76Ha7yGazGI1GiEajKBaLSCaT2Gw2mM1maLfbRlmfn58jn88b+qHBdjgcjOJkqJeRFsqk7XaLSCSCeDxueJMGGo2r3W6HQqGA09NTZDIZHA7fcx88F5FVd9PpFDc3N/jb3/6Gp6cnfPz40RjLrHbN5/PYbrfmOCxJF8x50ngulUoG78VigcPhYAz37XaLDx8+eIt75HxrdBkGfki52MhIBFzISoYH8MY9Z0hstVqhVCqhVqshn88bRcJNUplMBtls1tRv//d//zceHx+Rz+cBwOybGY/HaDabiEQimEwmWCwWyGQy5jBMAG8Sx4vFAjc3N3h+fsbp6anxkLTwCUt2v337hsFggGazaTZ59no9JJNJNJtNU15NC51FCVRO9HhKpRKi0Sj6/T4eHx8xmUyMN3Z6eorLy0vkcrk3c304HJBKpVCv11Gv143AIxPd39/j27dvGA6HaDabTuucY9put0gkEsjn829Cj9qakuhzuZwRnKxg2263Zr5jsZipXun1euj1eshms7i9vUWv18Pp6SkuLi5MO7lcDs1m81XSUnphTPRL71JjDCpNhn0oDG1mYejCvk5BxrkBYMIKw+EQ2WwWmUwGl5eXuLi4MNZqp9NBq9VCs9k04Qcp/FmIwRzXcDg0p3zLMl+uL0PHtoFi8xJzELPZDKPRCI+Pj0YhLhYLnJ+fo16vv8mT2uOlglmv1+h2uyaUWa/XzRFKFGZSyUhcNHpxKRAXfcnfZJv0pgaDAZLJJK6urowibrVaxkuOx+MoFouIRCKYTqembHk4HOLjx49vPLnpdIpWq4XD4YByuYxYLGYMTrbF6ADzF4VCAcViEScnJ1iv1+h0Ori9vcVwOMRut8PT05PBCQDK5bLJJ8/nc8znc7Tbbfz973/Hf/7nf2I8HqNYLGK//75JkimCy8tL7Pd79Ho9Ix+63S46nQ7m87nJ+xEvyjUap4lEwoRIadj45lvShox2hIXQykVL/MnFdnVsKyBb2VBoMPmWTqfx17/+Ff/2b/+GRqOBdDqN/X6P8XhsEqXb7Rb39/dGcK7XaySTSVMZweQyNf50OsVgMMDPP//8yrpfLpcYDAaYTCZIpVLY7/e4v7/H169fsdls8OnTJ3UsFBJMnLI0moR5e3uLTCaD7XZrkrz7/d4ccTOZTBCLxV55HczXMF6+2WyMF7TdblGtVl8pFy744XAwISx6ZOv1Gu12G//4xz9wd3eH5+dnk4iWORe2I9cwmUwahcASYRmjtoE5FgAmDDcejzEcDhGJRFAqlUy55Hq9NiEbWoLz+dwIvpOTExMSjcfjRuGenJwYhTkajUy4rFQqoVwum3i/Zu1S4Gw2GyQSCaRSKSMIaaWSfrgJzw4ZcQ5YkZfNZlEoFIzwyufzKJfLJiyaSCTenIPH/RW0rFnuzZLvTqdjcJ5MJkZY5HK5V/tgGEJm8pphyVQqZQypwWBgLHO2RUFDj0VL3HL+ZP5mOBzi5uYGNzc3WC6XyOfz6Pf75sQHWQ5L+iGfuhL7miKxrWibNiUwB9TtdjGZTFAsFnF5eWlCrs/Pz0in01gsFqhWq0in01itVnh5ecE//vEP/PrrrwCAs7MzbDYbk48FYJ6nIcIcx2azQTabNZ4Jc437/fcj7+lt07ikTIlGo3h8fESr1TK0Va/XTeh5MplgOp3i/v4ef//73/H4+Ih4PG7w4naAfD6ParWKSCRiCqASiYSRm4fDAbVazci7eDxuwqCfPn1CPp83ngyPjKFhTdBC7/Y6aevhgnd5LofD2xN2bUQA/3EvGtKbzcZYB5VKBf/6r/+Kf/mXfzExQVaVybj33d2diSFeXl6ahNVsNkMqlTKLk8lkzKSm02lz/AlLlr98+YKHhwcUi0VznhkFu0u7M+75+PiI5XJpLOx2u41Wq4WXlxczrmQyaU5vfnx8xH/8x3+g3++jXq8jk8mYeCndZoawaAm1Wi0Mh0OsVitjzdKiZIUMBRoFx2KxwN3dHb59+2YEAr0kKhitiikajaJcLhvvURt/kPWy2+1MhQpzMfQ8aKGR6X/66SeUSiXc3d2h1Wrh5OTEFAY0Gg1cXl6a3BrDpjw5IBqN4uzsDLFYzJTxanTGcm3iw+NBmMd7fn7GZDIxIZJarWbCDjbtp1IpVCoVE69nBSKrdiiMB4OB2fx7d3eHzWaDi4sLpFIp9Ho9dDodsx5cE1lhx3AKjSB68fR+JpOJ8fKZP6QhwBDYfr834TiGSi4vL5HP51/xpRbWkgYUKy9fXl6QzWax2WwwGo1MxSV3ilNI0ctidRbDnHYfUrnRi6cxSEWpyRg+Px6PzeZr5idSqRTu7u7Qbrex3+/N7nUqiC9fvhjD7fz8HNVq1Rh9NGIGgwFmsxlyuRw2mw06nQ6GwyFKpZIR0I+PjyY3SfzJL91u1xjCFxcXiEQi6HQ66HQ6Rq6s12vj1VOeUMnI0m7OOfPT3KeWSCSQTqdNZEEWK3EtuMny/Pwcp6eniMfjeHh4QK/XM4Zar9czSjSRSJhcjS0bfMalD97tuTC8EAY0oWQzLRUGN09Wq1VcXV2hXC6bMAArapij6Pf7Jj9zeXmJQqFgmLRcLuNPf/oT/ud//scoCkm0XJDtdotut4svX77g119/RT6fR61Ww2azQa1We5OIlbiv12u8vLyYvAJ3xnMz4+FwMLFuCsdKpYKXlxf8+uuvGA6HRiDIDYcAzJ6VWq1mmEKGUhh6mM/nxgMgc/KgyclkgsfHR4zHY5ydnSGXy5m8EEtopTLiuGKxmEnic7+MXCv57qqSoTfIWDNDQqy06na7iMVi+PjxI/785z9jt9vh5ubmVcXbarXCfr9HrVYz3zudDh4eHky4jccAlUolE3azw128bzQamaQmLTfmEe7v7w2jMZ5NoWyPkfk+Wn0Mt5GexuOx8ZyZM7u/v8dwOMRms0Gj0TDebDabNThxDLvdDu12G+Px2BRAUBjR6+LG2W63a86Vkrmb+XyOaDSKQqFglGSxWMTFxQWurq6MB2TzsRT6km8nkwn6/T4OhwNOT0/RaDRMcnq1Wplyc87Vbrcz3lShUEA+nzchVhpcpHcacFzfxWKBfD5vwrtcAztUySKHbreLSCSCSqVilGw+n8f9/T0Gg8GrMNLj4yO+fv2K1WqFDx8+4NOnTzg9PTU5MgrYXq+HSCRi6HY8HhtF0Gg00G63zakYAJDJZMw+r3a7bSITp6enaDabRmFwXGxzsVggl8uZk9o5l6R7yhQA5ny/VCqF5XJp0gPkL5bEHw7fc56Uc6yqJZ/TuGNOlHKABoEMDdsFHrJw4Z/iuXCxXe6r63feIwWZjOVNJhN0Oh0T/imXy682OTL+y78nLpVKJpFH5qP1QItkNBqh1WqZA97kfhmGXsbjMdrtNp6fn03BwOXlpYmfy7Ji+c7NSSwwYJiLOQASy2q1ehUiYxiEHgctYCb6SMhMZtPaYVUMrRG607PZzAipyWSCl5cXUyXT7/exXq+Rz+dxcXFhvAfGc2UeQK5JoVAwikX7MzXNe5EWJcNcdN8pIOkpjsdj5HI5fPz4EdVqFU9PTxiNRiZZnM/n34QrB4OBUZaMHTPUORgMjIVo514Wi4WxPJPJpBFYDG3QS2LJ58PDA8rlMrLZ7KtiE0nbrhOiWa0jX6wC4/ho4JTLZaTTaZOfqdVqKBaLJsxDb6Ver5t9DcvlErVazYRdNpuNKU6Rf0lxcnJivCsKm/Pzc1xfX5scgp10t9dQWqqsYKtWq/j06RMuLy9NDnQymZgTx1nQ8fT0hJeXF+NRVioVk+dhzo0FK+SZ1WqFp6cnTCYTVKtVHA4HowRlTo15NlZWzedz443SS2F5O/MOh8P3RPbNzY3JGf3pT3/C6ekpAGA4HJqwsTQEy+WymUN6DoVCwYQr+Vs+nzc5m06ng8fHRySTSZRKJWSzWWNgNptN/Pzzz0aBHQ4HU0XJY1yYcyuVSqYYJ5fLodFomAhANBo1Y2Y5eDqdfqXEmAfMZDKmKIHhO9IPo0EMZdoKRQuDaXTjg3crF5fnEqTNbCEmSzGn0ykmkwmSySROT09N9YaEbDaL6+trnJ6e4uzszDAOmaVSqeDjx49oNBpG0DJh2mg0zH6Bu7s7xGIxpNNpkyCmcqJ7fX19/WrHtI0/+2bIbjqdolar4fT01ITi6vW6qRTi/pzBYAAAJiZPq7JYLBrXmCcXZ7NZQ/RULtyQSMGVyWTw6dMnE167ubkBAHNyNPMNdJvp4TCpp60dFSSFtS+sKYFCaTabmSN6ZN6Grno8HketVkOz2TQFDExIptNpnJ6emhL0Xq+HWCxmktKpVArNZtPMHfMLw+HQ7LWQwn82m+H5+Rmz2QwfPnww+CyXS7TbbUynU+RyOWSzWbOB9/n5GZlM5pWnKyurGD7hSypgxriLxSL6/T6i0SgqlYoJD9ESpSCkUGb8nKcopNNpE6ZlCIz5DYZPEomE2QMkQ9a1Ws0cPLrffz9e5/LyEqVSCQCMR8UqJ/svGGQYhNEAnst1dXVlPOp+v49Wq4Xtdovz83Ocn59juVzi8fHRhFvI21R6/DNAbh2g8o3H48YTJ+1y8y7xi8ViJtfFtrPZLMrlsvG2Y7EYGo0Gzs7OsFgsUKlUTOiJuUHOPbc4MDzJPB6FNvMn3JvF5/L5PC4vL00E4OzszOSGmT8rl8sm/B6LxVCr1ZDJZPDhwwdTXbnf741nwfJhHs9CD0WeZM5QYSwWQ7lcRjT6/fQFGhjycE7mVOz9UAy3cdsAq9YYYtMO9QzrpWjwQ9Vidlmo6z4X2M+yOogxQnlkNgms2WyiUCigVquhXC4DgFEQjUYDFxcXaDabJmzx+fNnQ9BMctFCSqfTODs7QzabNdZVKpXC58+f8Ze//AXNZvPVmT32ZJ+cnKDRaOD6+toolvPzc1QqFYxGIzSbTVSrVZRKJcznc3S7XVNye35+jpOTE0OUTNQzHnt6emqSkNlsFqVSyZRAUhDJEliWAd/d3WE2m5nwF0sRGaqhQpXWjByTHVOlcLHX1LW+bINltbFYzFhEVAbpdBpXV1fGMmQYDQCq1So+fPhgKtq4aZblv4fDwVhvrH6iFXZ/f2+qCAuFgvE8KLBolXLeKBgZRgVgNjRSibGwIRKJvDnCHfgeQpTHaZAeI5EIGo2GUeDNZhOZTMaErFh1RpwYEmPokMYbFfx8Pke/3zfeL8NKLEigoKYAqdVqJh/BOY9Go5hMJubZw+Fg/oyPipRrLwsYKODohbBijZVa3W7XeNmlUslUR22321eFOFTerVYLX79+NWXu9E6ZU5KltQyLExjOJn8z/E1lzpxDpVLBp0+fzMbd8/NzHA4HjEYjAL/97XkqlTLhSfJGLBYzJf2k3fPzcwAw+2QymQyur6+RTCaxXC5RLBaN91Cr1YyXw+KaQqGA6+trpFIpFItFE9KiMUA+5FpwHcn79NZ4HxUgizioGCQNaKX1pGMWNNHAoJEkcbGjTD8K7865hMm3UFC5EvsSotEo8vk8/vznPyMWi5kkrmwrmUzi4uLCaPtEIoGffvrJWPz2buh0Oo0PHz6gWCwaQTcajfD8/GySacB3gfaXv/zF7Hz++eef8dNPP6m73CU+VA4nJycmTszwRDQaxc8//2wqfRg24PH119fXRlEwjkorjjX0tNpYCCDjyiRA5qMAmOeGw6E58YD9bzYbU85YqVRQr9dfjU97yUo7WkyuUKjcp8DPXD8WYZAeqtWq2cHOQotcLofr62sUi0WzpkyUUyABwNXVFdLpNNrtNr5+/YrZbGbi/u1228wbK82oSOhhsqScXstoNDJhEMa6ST9UDKQVWYYpFTHXm8qCIU7m62gtJpNJcwYWizxOTk5MSbz8q1qbyVlSSgVNb4k5I3qJDInQgGC4ieE+AGYsVGr09LSQIq362WxmeJRhYhaU0CBi7odKketPZckKxn6/j8VigWazaaIJkUjEGIyr1crkLXkYJiuaZJiHRTIM4VLxRCLfD9FkyDWXyxnjgTke5r8ymYzZAkC6iEQipjqPc0rPhR44hTsPyWRynYqJSpHrz7CZPGxXy13YYWgqFZvfotGo2TAtS+vtELbGs5QbDJHbbcv1l9ftnFdY+OEd+jbymiJxhVHkd4YOyHDU1vIeXmc4iq4d47Ky1p73c1HZX6VSMZ4EvYJYLIbPnz+j2Wwa91NW5Wi4E2cSNgUYF5cMTsuW8c/ZbGbim2RqjQnJpIy706rlc/xNJuNJiEzmJpNJE7NnToFMQ8tPWyue1cRcRKlUMiEHLR4rFQrDYqlUCrVazcSq+TuTpAxNEWda9tlsFvV63VyLRCL4+vUrJpMJSqUS6vU6DocD2u22SZiy/FrmxuQ+EOICwChxhu1YVkzPqtlsmhCLPJPL/u8LqVwYiqNxQNrggZ9SqdFz4sY7CmWppEgv8lBWGgakFXrbzBEuFgsTRiNN5/N5cw9DTeQRGiJUCDL3KcdJBUIc5PlkHHuhUHiFKwtR6vU6JpOJ4VNW4KXTaeNNnJ2dIZlMmvBVOp02/WWzWVxeXprSXypEzg3lgUxCc/15ViENLM6/PBKGHgWNNel9Sl4mL5F+ZR/c6yJzc1LJyTmRxrZPrsjffQLd9f8/fC4oL661b8tySec/6sH88Nli0prTchPyum/CGEvlImvHg9N9k9flBNv12WxXltLScpAb8KjJGcOUgt0er4a3PHeLLxnHZpvcHUxcpevKZ0iocr54CKLMUXEeJUOw1JT7YJjLIgNQ0WnxdX5mGOTp6Qm3t7fmGYaibBrgM/b4KRjoCcg545wTB1anseyaoQiWyy6Xy1dx9fF4jEwmg4uLCzQaDVNVRAUBwFiJh8P3pHCz2QSAV2vFTWWs0KI3RYOFBowMT9l0wFAlw3tcOxlqsO+Xf0krr/PZfD5vjlThffl8HmdnZ4ZmE4kEGo2GKRphZRa9FRZlfPjwAZlMxngXTBjTa2QEwOZRub78Z0caDcBvOddyuWy2AJB+mbhm6JFFHSwZJ13IQ0z3+98OUby4uDDGBz0rKTtk+IZro/GmzBuSZzKZjEmMcy3k5k/NIJb8JudFehFS9mjhKHndlpH2b5oQdykhe63sZ2w8tPG58LHltQuPIAitXHwdycFoRBrUpiz91NrRFuy9E0ArhJYIcaMgcFkKvvHYglWOQSoQJnTlRjGbIDUl5iIQ+ZnvtjKlq2zj4hoDq/Zub2/x9PRkLEstPMj7pXIhMJ91OBzelHLbbUhPTo6VGxM/fPhg9icxHPjx40ccDt93T9MgkeOQ88AYM5PGDJsw78WcHe9lKENbA40Gs9nsq3CtSzho9CGB3/P5vAnjUWBnMhmcnp6auaIxlE6njeKg0qHxQAXMqjE+y7m2z6pz0Xw2m8XV1dUrQ4X4yoQ1S56Zm0kkEuasNeY1gN/CpVRIXCfiIU/h5nrZ8y8NWpueXYYseUAaaza4vArbgPbJGFtAa7LJpocgcN2njdn+3SUbbbnFl0brmqIKCz/kuYTRbvIeWtiah+HS9rIv7bqGj09bBy2mbxE14vItjhybBprl4bMs5Dhdz7FdTVDIdbBxopJgxQyPKGei1N5IKZ/RlCX3gvCapjil1yuvy3HwqA0KLXo0DM9Iz9UW3MSFoSZb+VGJMPYsFbELNPpg5Q8VqXa/plxctMad7cSdxg/nk/wjz7KS1wmxWMyEQNmXrUw0nrB/l+OTG0sjkcgrT0niwvA2vU/pmfE+KnCbnuXRMT6ZIN+1ubbHI7+HNUaD+Epry1Zo9jWJo4v2Nbx945XvPtqSz2ovbcz2M+9VMj/0fy4+oafdK+Pu8l1rL6hfbUJ9bbkmL4jhpTJxLabWfhhrwcZbzpGP8W0lpxGDZmH5ijHYN++nBc8/amP4TY5RKhcbKKjlXNhCS5srbQ1sy1YLN7nAnmd+5/PSw9Tac9GRxJ9eAoA3Ho/rGRd+bMNeP5eno9G9PZ92kleutYu+JDAvpP1Oxc3fJI9TScjxu4xIeY+9E9ymeR9IHuKzQffboCkC7R7X3NvyRPOG7DlxyTMXf2hKwaU0wyiEMLRg4xwWftcmSltDa8JECiGXgLPBZ7W4tLVvQuT9PkYPM377uybMXR6G1qdGMFpbmmLR7nUJMxtn4O3R6gynxGKxV//1QJBlqvK5IM/TxbQ2Pj5vxp4Ll6Ky6dNuL4zlqtG6nV8i2B6B1r8LHw0v7Z4goeUT2vZ3aSiwTXsuNOHl4xHfpkwfPds4yZf0YFx0IPG28bXH5FMcYQRwkCdlgyYD5P0uGWF739o47Y2uNp8GyTOXPJLyw8drYeEP+bMwgssF5GcZltGYyaW17f6CFIOLsMOMwdWWfc1FrC6Px7b+tcWzX7ZrLfvXhISPCFzjkH0xh8D4tKwEk4JAKhl7TlzM45pb33XZlua52ULNJ9g1POW7ZvXK5zXloo3XJ2htHFyWbdBz2jMuGrHb8vGEq297HWza9yksV38aTvZ8uwRtEO7aXMnr9ph87djtaW2F8azs9sMoK7tPjQf5u8sDD+pDu26Hz31yxQc/5LnY1zXr3UZEsya0+4DfKlJcAtj3bNj77d98BBIGZ/u6XCANFw0P3z0uK1riH7QOkmG1MbDwAPhOrPYmSilEbM/FpwgluDxMTXDZNCd/twWaa8418NGMhn9Y2tMEl2/tw+JEeK8gdHklvvFp3rHsX75cikGj+yBhGqSIbNCUrD1+3/z41iCM0rDXIshb0mhA49cwNKYpF3vN7ec1YzisAS+v/VOUi+zA57LZ8B63LWhwLlzey7hhFpmgCbEweNtCV5ujIIbyKSON8WVll8tqs9fPJj65Z0Aex63ha3+WCsalRLS2+Iws5yUTyfG5lI82Xy6wn9fWxyfEgxRKmN9d4QcbbIHt47OwdO9af21dNY/EV8qu8aPMJdpywzaSwvC/tl6+dXcpWFdfYRSLD3w8q3kEQZ/ttjX+t708e8xhjBLffPrkow/e5blo1oe9GD5m8Qk1ux+X4ggjUMLeE0YwBE2q9pvMMfkY2cdYLvw0nDSrJIxA1Cxr35iD8OCauSwylyDju70TXgqsoBCJb52k5+Nbcx9Nap9d99jXgujMd81e5zBMbo/T9vaCxifnni+NxuxnfGPweYR2u74wmI9HbV7znbJhf36v4JTgMnBt2g6i0aC1tXOebNvmD5dM1fCzaUXiECYK4IPfndB/r+B1/e5SXC7LIyj8YuMXlqB89/vaf+8z2gvw5w34bgtd3zzZ13wC1qU0tPZ8QtlVaqy1HWZuwygA+YwdKnBB0Dh9z0kcfHMWpq8wkYAfwdPum4IprHVrr4FLAPp4wHW/j+ZkXy5L34WrbUgEyQkf/YVRcpLONc/MFUFwtRGGhlzKwQc+GeGSMxrO74E/9G+OCWEIwnW/6xnZn2+gLuHsEqiufuw+fWPRBKZNABo+QQsbViD72veN1Yd7GMINYtSgsWhKQMNZE4Qafva6289onmRYYePyyHxtaWPXQoba/a458OEZVjDZgtOeT984gnDV3vnSjlVy8XQQ/YW9HkQrPwKaUnAZeUHzYuMicXV5e/a1IHkbdG9Q6D+MzNTghw6udIU9AHeMU0PYp/XlfT7h53vG96wNYbW63Y/v3dWOL7zoGrstaHz3a88F3a/hETQe+d0XDg3bn+8535y5mNRuW55U4AoTaO2HiVm7xuIbs2w/jPfialuCrTTkffZeKnmPzdO+sQTNnexHvrtyDho+Wt8+8BkaLs/A12dY7zcsfr57ffz0eyAIJ5d889Hje+DdOReNICRS9jP2BkrtXp/mDVoI7XmbmbTf7MnU+gyrXOxnbNyIiwvv97TjAlswBAnM93y227DLqrV+7PH5cPOFuLT2bDy1e+214/zJU2l9fWn4aPjbnohvLYNoW+vTRzM+wWDzhC/m/17F5qKvoKgBjVOtLRctuPqxfw/67pJd0ktwtesS9q750doJ8hR9G0BdHoxs22UASdy1fn3zb9+n4eKDd50t5mIWH2G4mOM9BK0trtZnkHDlImr7I1za2sdIrj7t9oIYxO7PVxCgCX5NwLnGHzRfvuuutoOEJMfiEojaTnJ7fHY7YfrXFAzbkO9BQlcyJMHOXWj4uGjZh3MYD0Li7Kvocs2D1p92rwuChJJ9j7bzXhunLxzkmwsNP+2zNr7D4eCsZg3bnw1hrH7XvAPu43G0l+ZhaWO0FYy8T5OHNvzIXPxQKbIkKHsQroWxBS8/y99cCx6G2FwMYguEIOXiU5D2Amr9+UJW2lzYuNr7R+xzo96rLFyKQ8NNvtuhDZcXor0HhTbs+eK+Jt/8BrVHCLIQOTa7pNYldIO8S4m7a37CCBsNT7svSaMuGgfe/lusdp8999p9Nv4+ReQ7Roc0zaOE7PmSNO/bma/xof2brchs2nLJBW2+XH0Fgb3fyp4Tux8XH0ncNfngk7XaZl6tfy2i4uO998zHDyX0bSEaxFg+weqyHm3L0GXRuQgm7DVe186G8j0jfw9KiGnhOfmsTTDa7lttHFqbdvuue31KUDuU0te+hoMGtkCUTMR+tPt9gkZ+1qwyTcHYY7DvJ8j2XJ4h8fe151o7n9HkExxB80GcgixQuQ6aN+HqX8NP8qu2zqQrKjRXe7ag98kHDbQxBbWlzZc9Rs0olhDWgPDhy+9yDmTFmUvOuNbURWeuOXDxRtAYXPC7qsXkdWkp+CZfW/ggAR4GL3sytUXTGCcoNKK14xMYQW1rDKf9Lj9rCVJbYIYN6YUhHNeYfXPuagfQPTSXcHIdrql9DjMOCRoNani5Qg2yfd88+nB4z/0avdrj0J4J6stu/3DQK7lsHIKEr4t2ZXuafHDxrissFDQ2+zf+46ULf82Ile1oNGDPh1SstuHsi9C4xhYm7OpbD5/ydRmWvr6lURBEV4TfffwLr2mC1BXO4XeXgvG5XS6G852jpAlBjTFcePr619ojuBQXv/MfE13tc0F9TCavSwLX2vStjWTqoA1fQfMQxtPxEbcr7KNZjq5+NLANIBcthQX7eR+9u665PCqt/SA8XXP/XqvaVgYSV59As8ejKRsZ2pPPuYSeNh+uddYUky3sXQZf2FCPa73luLQxaZ6v9l0zgGTfLi8kyEv14WPf65pX1+8u+CHPxaXJfZ36Jg0Id8yKqy+XsJXCMqgNXzs2/nz3WSRyfJrG3+12bzZD2uEoF85hBL99r+85F6FrY9Se8Qkvn7J4L+62cJP3ufAM6kfr177uCyu4QnquvoJ4xkfX2nwHWcUSwggJm/58Asp3j0ZTLggjRzSl4qPJw+Ftoj7oWfnu8jq0e/jZ1Z8r0qHxg6ZgtPZ+NAznG7P2+UcVC/AD+1y4aD6ms8FnTWtnFbnAZxVpOLiEmRQMQV6BPc6wzGkTm8a0WuLPbst2sbX+td+1OQo6/uNHBLNkNE3Y+oSM/OzC396b4avske2HEfYuK9zGzdWGnWvRmF5rT1s3+94gxif+LoFrh3l8oRAtemD36eKTIMVi48nv8tp758x1j42vb9yua/IZKe+0Z238XfPr6yuoLR8dav3aMtL1nB3p0XDzyZ4w8G7looVqwobEfMxgP+sbiI+4ZZv2NW3ibQLWhKFUFD4Csp/Xzspyjc/F1DaD+Jjah4+LkH1E6Bqnja92Tbvfhav2u2sdfM+GVQ5h+neFDYPuD5pLbc5c3phrbIAuPDWhLt9d43X1LZ9/jwDVcNZwCAqDhcU5LPhoyHWfa55tsJVlEL2EodX38GYQf7joTPvukj3yWhh4l3Kxqzjeq9V8Ql9+1gYVZJn/0SDbDxvycF3TcP09glD77T2WZZg+fEzoE6w+4rbxDAJfexJP7TefcrDpzH4+SBhrgj7seLTnfUz+HmXlUi787Fpnrc0wBl7QZw1s7+69SjkIXEJdkx+2dxem/zC0/B5PzIVnEC6a8S7XzaY1V/RFa8O+J4i/XRA5/LOk8xGOcIQjHOH/Wwj+z+EjHOEIRzjCEd4JR+VyhCMc4QhH+MPhqFyOcIQjHOEIfzgclcsRjnCEIxzhD4ejcjnCEY5whCP84XBULkc4whGOcIQ/HI7K5QhHOMIRjvCHw1G5HOEIRzjCEf5wOCqXIxzhCEc4wh8O/wfEx/7/wk0HIAAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Convert PIL Image to Tensor\n", - "to_tensor = transforms.ToTensor()\n", - "image = to_tensor(image)\n", - "\n", - "# Define each transformation separately\n", - "# RandomAffine: applies rotations, translations, scaling. Here, rotates by up to ±15 degrees,\n", - "affine = transforms.RandomAffine(degrees=15, translate=(0.1, 0.1), scale=(0.9, 1.1))\n", - "\n", - "# ElasticTransform: applies elastic distortions to the image. The 'alpha' parameter controls\n", - "# the intensity of the distortion.\n", - "elastic = transforms.ElasticTransform(alpha=50.0)\n", - "\n", - "# RandomPerspective: applies random perspective transformations with a specified distortion scale.\n", - "perspective = transforms.RandomPerspective(distortion_scale=0.2, p=1.0)\n", - "\n", - "# RandomErasing: randomly erases a rectangle area in the image.\n", - "erasing = transforms.RandomErasing(p=1, scale=(0.02, 0.33), ratio=(0.3, 3.3), value='random', inplace=False)\n", - "\n", - "# GaussianBlur: applies gaussian blur with specified kernel size and sigma range. \n", - "gaussian_blur = transforms.GaussianBlur(kernel_size=(5, 9), sigma=(0.4, 5))\n", - "\n", - "# A list of all transformations for iteration\n", - "transformations = [affine, elastic, perspective, erasing, gaussian_blur]\n", - "\n", - "# Vertical stacking of transformations\n", - "fig, axs = plt.subplots(len(transformations) + 1, 1, figsize=(5, 15)) \n", - "\n", - "# Permute the image dimensions from (C, H, W) to (H, W, C) for display\n", - "display_image = image.permute(1, 2, 0)\n", - "\n", - "axs[0].imshow(display_image)\n", - "axs[0].set_title('Original')\n", - "axs[0].axis('off')\n", - "\n", - "for i, transform in enumerate(transformations, 1):\n", - " augmented_image = transforms.Compose([transform])(image)\n", - " # Permute the augmented image dimensions from (C, H, W) to (H, W, C) for display\n", - " display_augmented = augmented_image.permute(1, 2, 0)\n", - "\n", - " axs[i].imshow(display_augmented)\n", - " axs[i].set_title(transform.__class__.__name__)\n", - " axs[i].axis('off')\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "3b777825-d1ce-4e12-9cda-678252379467", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Path to the image\n", - "image_path = '../static/image_augmentation.png'\n", - "\n", - "# Open the image\n", - "image = Image.open(image_path)\n", - "\n", - "# Convert PIL Image to Tensor\n", - "to_tensor = transforms.ToTensor()\n", - "image_tensor = to_tensor(image)\n", - "\n", - "# Define your transformations here\n", - "affine = transforms.RandomAffine(degrees=15, translate=(0.1, 0.1), scale=(0.9, 1.1))\n", - "elastic = transforms.ElasticTransform(alpha=90.0)\n", - "perspective = transforms.RandomPerspective(distortion_scale=0.2, p=1.0)\n", - "erasing = transforms.RandomErasing(p=1, scale=(0.02, 0.33), ratio=(0.3, 3.3), value='random', inplace=False)\n", - "gaussian_blur = transforms.GaussianBlur(kernel_size=(5, 9), sigma=(0.1, 5))\n", - "\n", - "# Combine all the transformations\n", - "all_transforms = transforms.Compose([\n", - " affine,\n", - " elastic,\n", - " perspective,\n", - " erasing,\n", - " gaussian_blur\n", - "])\n", - "\n", - "# Apply combined transformation\n", - "augmented_image_tensor = all_transforms(image_tensor)\n", - "\n", - "# Set up matplotlib subplots\n", - "fig, axs = plt.subplots(1, 2, figsize=(10, 5))\n", - "\n", - "# Display original image\n", - "axs[0].imshow(image_tensor.permute(1, 2, 0)) # Change to (H, W, C) for display\n", - "axs[0].set_title('Original')\n", - "axs[0].axis('off')\n", - "\n", - "# Display augmented image\n", - "axs[1].imshow(augmented_image_tensor.permute(1, 2, 0)) # Change to (H, W, C) for display\n", - "axs[1].set_title('Transformed')\n", - "axs[1].axis('off')\n", - "\n", - "plt.show()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "49f1589c-9ecb-4c7e-9fa2-71e517ededbb", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Missing modules for handwritten text generation.\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA38AAADmCAYAAABlNjyZAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAABj8UlEQVR4nO2deZBW5Z39T4MRRYW4ISpK0ywioHSEgYTEiBtIcMOAiVOJtMF9xi2GyeAPUUMGhhEdU2o0RgVRRyWCsbRGARUcowgag+KCgoAim6ICGnfp3x/WvXXueZ/vS7dKEN7zqeqq+z59l2e723PP9zxV9fX19TDGGGOMMcYYs1XTZHNnwBhjjDHGGGPMpscvf8YYY4wxxhhTAfjlzxhjjDHGGGMqAL/8GWOMMcYYY0wF4Jc/Y4wxxhhjjKkA/PJnjDHGGGOMMRWAX/6MMcYYY4wxpgLwy58xxhhjjDHGVAB++TPGGGOMMcaYCsAvf+Ybx6xZs1BVVYVZs2Zt7qwYY4wxxhiz1eCXvy2MiRMnoqqqKvx78sknN3cWv5Fcd911GDJkCPbdd19UVVWhrq5uc2fJGGOMMcaYfyjbbO4MmC/Hb37zG7Rr164kvUOHDpshN998xo0bh/feew+9evXCypUrN3d2jDHGGGOM+Yfjl78tlAEDBqBnz56bOxtbDI8++mj+1W/HHXfc3NkxxhhjjDHmH45ln1spl1xyCZo0aYKHH364kH766adj2223xbPPPgsA+OSTTzBq1Cj06NEDLVu2xA477ICDDz4YM2fOLGy3dOlSVFVVYfz48bj22mtRU1OD5s2bo1+/fli2bBnq6+sxevRotGnTBttvvz2OO+44vPPOO4V9VFdX4+ijj8b06dNRW1uL7bbbDl26dMHUqVMbVKY5c+bgqKOOQsuWLdG8eXMccsghePzxxxu0bdu2bVFVVdWgdY0xxhhjjNka8cvfFsq6deuwZs2awt/bb7+d/3/kyJGora3FsGHD8N577wEApk2bhj/+8Y8YNWoUunfvDgBYv349brzxRvTt2xfjxo3DpZdeirfeegv9+/fHvHnzSo57++234/e//z3OOeccXHjhhXj00Udx4oknYuTIkXjwwQfx61//Gqeffjruu+8+/OpXvyrZfuHChfjJT36CAQMGYOzYsdhmm20wZMgQzJgxo2x5H3nkEfzwhz/E+vXrcckll2DMmDFYu3YtDjvsMMydO/cr1KQxxhhjjDEVQr3ZopgwYUI9gORfs2bNCuvOnz+/ftttt60/9dRT69999936vffeu75nz571n376ab7OZ599Vv/xxx8Xtnv33Xfr99hjj/pf/OIXedqSJUvqAdTvvvvu9WvXrs3TR4wYUQ+gvnv37oX9nnTSSfXbbrtt/UcffZSntW3bth5A/ZQpU/K0devW1e+555713/nOd/K0mTNn1gOonzlzZn19fX39hg0b6jt27Fjfv3//+g0bNuTrffDBB/Xt2rWrP/LIIxtVhzvssEP90KFDG7WNMcYYY4wxWzqO+dtCufbaa9GpU6dCWtOmTQu/u3XrhssuuwwjRozAc889hzVr1mD69OnYZpttCttk223YsAFr167Fhg0b0LNnTzzzzDMlxx0yZAhatmyZ/+7duzcA4Gc/+1lhv71798Ydd9yB5cuXo6amJk/fa6+9MGjQoPx3ixYtcPLJJ2PcuHFYtWoVWrduXXLMefPmYeHChRg5cmTh6yYAHH744bj11luxYcMGNGniD9nGGGOMMcZE+OVvC6VXr14NMnwZPnw47rzzTsydOxdjxoxBly5dSta55ZZbcMUVV2DBggX49NNP8/SUm+i+++5b+J29CO6zzz7J9HfffbeQ3qFDh5LYu+wldunSpcmXv4ULFwIAhg4dmi4kvpDB7rzzzuH/jTHGGGOMqXT88reVs3jx4vzlaf78+SX/v+2221BXV4fjjz8ew4cPR6tWrdC0aVOMHTsWr776asn6+nVxY+n19fVfIfdfsGHDBgDA5Zdfjtra2uQ6dvA0xhhjjDGmPH7524rZsGED6urq0KJFC5x//vkYM2YMBg8ejBNOOCFf5+6770ZNTQ2mTp1a+CJ3ySWXbJI8LVq0CPX19YVjvfLKKwC+cANN0b59ewBfSESPOOKITZIvY4wxxhhjtnYcJLUVc+WVV+KJJ57ADTfcgNGjR6NPnz4466yzsGbNmnyd7Isdf6GbM2cOZs+evUnytGLFCtxzzz357/Xr12PSpEmora1NSj4BoEePHmjfvj3Gjx+P999/v+T/b7311ibJqzHGGGOMMVsT/vK3hfLAAw9gwYIFJel9+vRBTU0NXnrpJVx88cWoq6vDMcccAwCYOHEiamtrcfbZZ2Py5MkAgKOPPhpTp07FoEGDMHDgQCxZsgTXX389unTpknzR+qp06tQJw4YNw1NPPYU99tgDN998M1avXo0JEyaE2zRp0gQ33ngjBgwYgK5du+KUU07B3nvvjeXLl2PmzJlo0aIF7rvvvrLHve+++/K5DT/99FM899xz+O1vfwsAOPbYY3HggQd+fYU0xhhjjDHmG4hf/rZQRo0alUyfMGEC2rZti6FDh2K33XbDVVddlf+vY8eOGDt2LM477zxMnjwZJ554Iurq6rBq1Sr84Q9/wLRp09ClSxfcdttt+NOf/oRZs2Z97fnu2LEjrr76agwfPhwvv/wy2rVrh7vuugv9+/cvu13fvn0xe/ZsjB49Gtdccw3ef/99tG7dGr1798YZZ5yx0eNOmTIFt9xyS/77b3/7G/72t78BANq0aeOXP2OMMcYYs9VTVf91OHIY0wCqq6vRrVs33H///Zs7K8YYY4wxxlQcjvkzxhhjjDHGmArAL3/GGGOMMcYYUwH45c8YY4wxxhhjKgDH/BljjDHGGGNMBeAvf8YYY4wxxhhTAfjlzxhjjDHGGGMqAL/8GWOMMcYYY0wF0OBJ3tesWZNMr6qqSqZ/+OGHyfSmTZuWpO28887JddetW5dM/+yzz5LpzZs3T6Y3aZJ+x3333XeT6bvuumsy/aOPPipJa9GiRXLdJUuWJNOj+tppp52S6Rs2bEim77XXXsn0tWvXNjh9n332Sa67evXqZHpUX9tvv30yPar3qKxRXX7yySclaR988EFy3c8//zyZ3rp162R61MeiMr399tvJ9KidUn2psXmP+kx0zMbUY7n0HXfcsSTtnXfeSa4b5XGbbdKXmCiPUb0bY4wxxpivjr/8GWOMMcYYY0wF4Jc/Y4wxxhhjjKkA/PJnjDHGGGOMMRWAX/6MMcYYY4wxpgLwy58xxhhjjDHGVABV9fX19Q1ZccGCBcn0yHWyMW6fkSvk3//+92R6y5Ytk+kpN04A2GWXXZLpkXNj5H747W9/uyQtclyM3A+jMkXN0KxZs0btJ2L33XcvSfv000+T60auk5Ez5p577plMj8oUtXfkKJvKZ6tWrZLrfvzxx8n09957L5me6o9A7FIZ9bGoT6acaaN6iVxAo/4b5TGqx8hlNcp7ishpN3KCTTmGAsBrr72WTO/cuXOD82KMMcYYYxqHv/wZY4wxxhhjTAXglz9jjDHGGGOMqQD88meMMcYYY4wxFYBf/owxxhhjjDGmAvDLnzHGGGOMMcZUAA12+4zcOyOHwshZcNmyZSVpkdvg9ttvn0xfu3ZtMj3KY+QuGTlyRukp58LILTJynYzy8q1vfatReWmsy2hq/ah+ozZdvXp1Mj3aT5SX5s2bN2o/KbfPKI/RvqO8RC6VO++8czI96mO77rprMj3lMrrtttsm143cV6M+E/W9qJ0iV9bIwTR1nkVOuJHrb1TvUVtH7rbGGGOMMear4y9/xhhjjDHGbCXMmjULVVVVmDVr1ubOivkG4pc/Y4wxxhhTEUycOBFVVVXh35NPPrm5s/iN48MPP8SwYcPQrVs3tGzZEjvuuCO6d++O3/3ud6FqyXxzSc8SbYwxxhhjzFbKb37zG7Rr164kvUOHDpshN99sPvzwQ7zwwgv40Y9+hOrqajRp0gRPPPEELrjgAsyZMwf/8z//s7mzaBqBX/6MMcYYY0xFMWDAAPTs2XNzZ2OLYJdddin5InrmmWeiZcuWuOaaa3DllVeidevWmyl3prFY9mmMMcYYYwxxySWXoEmTJnj44YcL6aeffjq23XZbPPvsswC+MEIbNWoUevTogZYtW2KHHXbAwQcfjJkzZxa2W7p0KaqqqjB+/Hhce+21qKmpQfPmzdGvXz8sW7YM9fX1GD16NNq0aYPtt98exx13HN55553CPqqrq3H00Udj+vTpqK2txXbbbYcuXbpg6tSpDSrTnDlzcNRRR6Fly5Zo3rw5DjnkEDz++ONfuo6qq6sBxEaM5ptJg90+o4aNXC3feuutZPoee+xRkvb+++8n1913332T6evXr0+mR06EkZNmY50bU86QUV4iB9Mo/bPPPkumR/X7+eefJ9OjMqXcPvfee+/kulF7bLNN4z4URy6Skdtl5GCaSo/yEh0zIqqv7IKmvPDCC8n0XXbZJZmeymerVq2S60bnWHSKRmWN+tiaNWuS6ZGzaeq4b7zxRnLdrl27JtNTbqdA7AZsjDHGbEomTpyIU045BQ899BC6d+9e+F9VVVX+DPjpp5+id+/eeOeddzB//nzstNNOmDZtGo466iiMHj0aI0eOBPDFvfXAAw/ESSedhI4dO+K9997DTTfdhMWLF2Pu3Lmora0F8MXLX7t27VBbW4tPPvkEp556Kt555x3813/9Fw466CAcdthhmDVrFn76059i0aJFuPrqq1FXV4ebb745z191dTWaNWuGN998E2eeeSZatWqFCRMm4IUXXsCDDz6II488EsAXhi+HHnooZs6cib59+wIAHnnkEQwYMAA9evTA4MGD0aRJE0yYMAELFizAY489hl69em207j755BOsX78eH374IZ5++mmcffbZaNasGRYtWtToZ0Sz+XBLGWOMMcaYiuKII44oSWvWrFk+sPqtb30LkyZNQo8ePfDLX/4Sl19+OYYNG4aePXvi3//93/Ntdt55ZyxdurQwsH3aaaehc+fOuPrqq3HTTTcVjrF8+XIsXLgwH6j9/PPPMXbs2PyFKnuJeuutt3D77bfjuuuuK0yD9Morr2DKlCk44YQTAADDhg1D586d8etf/zp/+VPq6+tx5pln4tBDD8UDDzyQT8N0xhlnoGvXrhg5ciSmT5++0TqbOnUqTjrppPx3z549cfPNN/vFbwvDrWWMMcYYYyqKa6+9Fp06dSqk6fy53bp1w2WXXYYRI0bgueeew5o1azB9+vTCy07Tpk3z7TZs2IC1a9diw4YN6NmzJ5555pmS4w4ZMqSg0OnduzcA4Gc/+1lhv71798Ydd9yB5cuXo6amJk/fa6+9MGjQoPx3ixYtcPLJJ2PcuHFYtWpVMvZu3rx5WLhwIUaOHIm333678L/DDz8ct956KzZs2BDOK5xx6KGHYsaMGVi7di0efvhhPPvss/j73/9edhvzzcMvf8YYY4wxpqLo1atXgwxfhg8fjjvvvBNz587FmDFj0KVLl5J1brnlFlxxxRVYsGBBYeqDlJuohjRlL4L77LNPMl1Djjp06JB/ucvIXmKXLl2afPlbuHAhAGDo0KHpQgJYt25dGAaSsccee+ThW4MHD8aYMWNw5JFHYuHChTZ82YLwy58xxhhjjDEJFi9enL88zZ8/v+T/t912G+rq6nD88cdj+PDhaNWqFZo2bYqxY8fi1VdfLVlfvy5uLL2B1hxlybwTLr/88jwGUdlxxx0bvd/Bgwfj//2//4d7770XZ5xxxlfJovkH0uCXv+233z6ZHnXKyDRFRyuA2ABk9erVyfRo/UhzHH3GjoxgIsMT1lxnRKYp0WfwyAgnMjtp3rx5Mj2qg8j0JrWfyKwmZWwDlI5KZaxbty6ZHhmPRMdN9Q0gXe+ptHJE9RX138h8Zffdd0+mR30vVe9Rv47Oscg0JRqhi8oaGb5Eef/2t79dkrb//vsn103d4IAv5CmNyctuu+2WTDfmm0TKTMEYs/WxYcMG1NXVoUWLFjj//PMxZswYDB48OI+3A4C7774bNTU1mDp1auE55pJLLtkkeVq0aBHq6+sLx3rllVcAxGZ17du3B/CFRDQV6/hlyUzzoudA883EUz0YY4z52pg4cSKqqqrCP50rygDLli3DZZddhl69emHnnXfGbrvthr59++Khhx7a3FkzpqK58sor8cQTT+CGG27A6NGj0adPH5x11lmFAczsix0PJs+ZMwezZ8/eJHlasWIF7rnnnvz3+vXrMWnSJNTW1obSyx49eqB9+/YYP3588gNH9GEiY82aNcnB8htvvBEAPF/iFoZln8YYY752fvOb3yTjXTp06LAZcvPN5t5778W4ceNw/PHHY+jQofjss88wadIkHHnkkbj55ptxyimnbO4sGrPV8cADD2DBggUl6X369EFNTQ1eeuklXHzxxairq8MxxxwD4IvBrdraWpx99tmYPHkyAODoo4/G1KlTMWjQIAwcOBBLlizB9ddfjy5duoRKsq9Cp06dMGzYMDz11FPYY489cPPNN2P16tWYMGFCuE2TJk1w4403YsCAAejatStOOeUU7L333li+fDlmzpyJFi1a4L777gu3v+2223D99dfj+OOPR01NDd577z1MmzYNM2bMwDHHHIPDDjvsay+n2XT45c8YY8zXzoABAzwa3EAOPfRQvP766wXZ85lnnona2lqMGjXKL3/GbAJGjRqVTJ8wYQLatm2LoUOHYrfddsNVV12V/69jx44YO3YszjvvPEyePBknnngi6urqsGrVKvzhD3/AtGnT0KVLF9x2223405/+hFmzZn3t+e7YsSOuvvpqDB8+HC+//DLatWuHu+66C/379y+7Xd++fTF79myMHj0a11xzDd5//320bt0avXv33mi83g9+8AM88cQTuOOOO7B69Wpss8022G+//XDllVfinHPO+TqLZ/4BWPZpjDHmH84ll1yCJk2a4OGHHy6kn3766dh2223x7LPPAvgijnnUqFHo0aMHWrZsiR122AEHH3wwZs6cWdhu6dKlqKqqwvjx43HttdeipqYGzZs3R79+/bBs2TLU19dj9OjRaNOmDbbffnscd9xxeOeddwr7qK6uxtFHH43p06ejtrYW2223Hbp06YKpU6c2qExz5szBUUcdhZYtW6J58+Y45JBD8Pjjj290u65du5bEuzZr1gw/+tGP8MYbb4Rxv8aYxlNXV4f6+vrwr66uDk2bNsXcuXOxbNmyEv+Cc889F/X19TjxxBMBfOFXMGLECCxduhQfffQRnnnmGQwcOBATJ07E0qVL8+2qq6tRX1+PX/3qV4X99e3bF/X19Rg8eHAyn6lBtH79+uHZZ5/FRx99hJdeeqlk22yfGpNcW1uLKVOmYM2aNfjoo4+wdOlS3HXXXRv9ctezZ09MnjwZr732Gj766CO8//77+Otf/4oLLrjAc/xtgfjlzxhjzNfOunXrsGbNmsIfzy81cuRI1NbWYtiwYfnLzbRp0/DHP/4Ro0aNQvfu3QF8Ec9y4403om/fvhg3bhwuvfRSvPXWW+jfvz/mzZtXctzbb78dv//973HOOefgwgsvxKOPPooTTzwRI0eOxIMPPohf//rXOP3003HfffeVPIQBX1ii/+QnP8GAAQMwduxYbLPNNhgyZAhmzJhRtryPPPIIfvjDH2L9+vW45JJLMGbMGKxduxaHHXYY5s6d+6XqcNWqVWjevHlo/GWMMcY0lqr6BnrI6qSQGR999FGjDphyKMzcgpQPPvggmR45Y0Y2uY1xHgWA7bbbLpmuo8QA8NlnnyXXjfIeHTObN0VZtWpVMj1yu4zcKFNOTJErZOTaFDkxRu0XuVpGAclRXX7++eclaZElcVTv0ch51DdSbQ3EjpwtWrRocH4iR9ao/0Z9ZqeddkqmR06lkftq5Eybcsn9+OOPk+tGD6cpx1Agrt9ddtklmW62HCZOnBjKFJs1a1a4Zzz//PPo0aMHTj75ZFx++eXo1q0b9txzT8yePTsfTf7888/x+eefF65Xa9euRefOnTFw4EDcdNNNAL748teuXTvsvvvuWLhwYd7fL7roIowdOxbdu3fH008/ne/3n//5nzFlyhSsX78+v55WV1fjtddew5QpU3I3v/Xr16Nz585o3bp1PmGzun3W19djv/32Q01NDR544IH8nP3www/RtWtXdOjQAdOnT29UPS5atAgHHHAAhgwZgkmTJjVqW2PM1kl1dTW6deuG+++/f3NnxWzB+FutMcaYr51rr702n3g4Qwc4unXrhssuuwwjRozAc889hzVr1mD69OkFGVHTpk3z7TZs2IC1a9diw4YN6NmzZ/4yxgwZMqQw0NG7d28AwM9+9rPCfnv37o077rgDy5cvR01NTZ6+1157YdCgQfnvFi1a4OSTT8a4ceOwatWq5ODVvHnzsHDhQowcObJkoPTwww/Hrbfeig0bNoTTDikffPABhgwZgu233x7/+Z//2aBtjDHGmIbglz9jjDFfO7169WqQ4cvw4cNx5513Yu7cuRgzZgy6dOlSss4tt9yCK664AgsWLMCnn36ap6fcRPfdd9/C7+xFUOcpzdJ1XtMOHTqUfG3PXmKXLl2afPnLJoAeOnRoupD4QlERzc3JfP755/jpT3+KF198EQ888EA4V6YxpvLgGEJjvix++TPGGLPZWLx4cf7yNH/+/JL/33bbbairq8Pxxx+P4cOHo1WrVmjatCnGjh2LV199tWT9SD4dpTcw8qEsWSjC5Zdfjtra2uQ6kVRdOe2003D//ffj9ttvt326McaYrx2//BljjNksbNiwAXV1dWjRogXOP/98jBkzBoMHD87j7QDg7rvvRk1NDaZOnVr4InfJJZdskjwtWrQI9fX1hWO98sorAL6It0nRvn17AF9IRI844ogvfezhw4djwoQJuOqqq3DSSSd96f0YY4wxEXb7NMYYs1m48sor8cQTT+CGG27A6NGj0adPH5x11llYs2ZNvk72xY6/0M2ZMwezZ8/eJHlasWIF7rnnnvz3+vXrMWnSJNTW1oZmVT169ED79u0xfvz45KTOb7311kaPe/nll2P8+PG46KKLcN555335AhhjjDFlaPCXv8idL3IQjALbU66h0Q01chJtrFtiyi0SAJYvX55MjxwgU86FK1euTK77rW99K5keuUVGjpk77LBDMj1yxoxcWVNulKmHlGhdAOFcLpEbpcbYZETOm5Fj5JtvvlmSFrlCRm0d9ceoz0Tt19j1U+0dlT/qG5Gza9QHorii6AE0kr3tueeeJWkaH5UR1e+KFSuS6ZGjrtl6eOCBB7BgwYKS9D59+qCmpgYvvfQSLr74YtTV1eGYY44B8IVTaG1tLc4++2xMnjwZAHD00Udj6tSpGDRoEAYOHIglS5bg+uuvR5cuXcJr2FehU6dOGDZsGJ566insscceuPnmm7F69WpMmDAh3KZJkya48cYbMWDAAHTt2hWnnHIK9t57byxfvhwzZ85EixYtcN9994Xb33PPPfi3f/s3dOzYEfvvvz9uu+22wv+PPPLI0BHabDmoWzI7l2/MOV3vy+ymrZJivTfwPVrvVXrtVvdnft5q1apV4X96/vFx9BqveXr99dfzZf2iro7ueg/ke5muq67kr732Wvi/9evXF37vvffehd/snK33fj0u70ufT7Se1AWc45T1GU6fDfk5VB2/9XlU+0z0nJI6DpdHn9H1uDxYB5Tvy+pIz3W8sfbhdfXdQ59Dtf+VmytV25b3pW2n6+p1mc8fddTXbbl8en5o/rW/cRto/aee3RTLPo0xxnztjBo1Kpk+YcIEtG3bFkOHDsVuu+2Gq666Kv9fx44dMXbsWJx33nmYPHkyTjzxRNTV1WHVqlX4wx/+gGnTpqFLly647bbb8Kc//QmzZs362vPdsWNHXH311Rg+fDhefvlltGvXDnfddRf69+9fdru+ffti9uzZGD16NK655hq8//77aN26NXr37o0zzjij7LbZhPYLFy7Ez3/+85L/z5w50y9/xhhjvhb88meMMeZro66uDnV1dRtdL5r4/Nxzz8W5556b/66qqsKIESMwYsSIwnoDBw4s/K6urk5+xc7m4WtMPvv164d+/fqFeY/2WVtbiylTpoTbRVx66aW49NJLG72dMcYY01j88meMMcYYs4lR6T1Lu1RKpzI8Db1hqafKCFVexuEQKidTuZyGTnC4h8rLdACEpWlaVp2yhKWcul/9yq2SPT6uShs1/ywPVNmtyvI0z1FYE1CUIAJFSazmQWWTq1atCveldapl5/AYzYO2pZaX88VT5gClssJy+9H+ppJFbj+VEWsdc/9iKTNQKjNet25dvqxyZQ1J0TAtli+rTFrLznnWc0nrQqWpfH5t7BxmmbHmQetYWbJkSb7ckCmEFBu+GGOMMcYYY0wF4Jc/Y4wxxhhjjKkAGiz7TDldAqXOPRn6WbvcfvSTf0bkQqjyiIzos3WUHjkOquNQRsrxNHJi1E/dGZEzZuTcGOUxcvPhz+JMytlUna02to/IWS9ywNTP4RmRI2d03LZt25akRe6zUf021jEz6jORI2lU1lQfjuoxOpeiPEbnR1Q3kaNs5Lar8gYgbqOoXqK8G/NNZOnSpZs7C2Yrpk2bNoXfLNtTeZ9KElWmx3I5lScuW7as8Juvz+rEqPdjfebg+4Bez/W+yvtSp/Jyrpya/41JBXlblf9pHvk+qW6X+iypdcy/1WVeXeE5j3qv1fKprJX3re2hclnuM5pfvQ/rvrhu1F1c7+0sp9X9qvO7blvuOJon7o8bc2/m4+q7hJ4/2ta8reZBnxtZRqn70T6vz35cBn1Gq6mpKfzmttTj6LZ6PeDnNj0/omdJxl/+jDHGGGOMMaYC8MufMcYYY4wxxlQAfvkzxhhjjDHGmArAUz0YY7YKWD/POny2deaYLtbMs05/n332yZc17pFjAziGheMJON6B98sxFBxX88Ybb+TLHPvB6/BxOdaBj8vLb7/9dr6ssQQMx8vwsTmvXIZddtklX37zzTeT+eN1OA6Dras5HohjGTg2WeNiOA6IY1C43FwGzhO3Cccoc8wMx+lwbAb3Ad4n9zHuCxqbEVmzc7/kY3CbcPwutyPvk8vA6Vxmzh+Xn+NXuPxqhb5w4cJ8uUOHDvky26tzW3Mf5f1ynjguheuFy6DxQql9cnk0/ovrleuP1+O64X7PcUHsSxDFyjcEjQXjeCeN39Jrj8bi8bba5zTejs9VbVutM40Z53bS2CgtD59/GpOlx+HzWferMWTlYpg0TkynfuA+rrGEOj2A+gtw39LjaKwX51H/pzF/Gv/IbaJ+GRpvF92DgOK1FyitRy6/xkbqcbhPaftof9M4uNdeey1f1mkINOaU+4XGUWpsIZ8TWk+aB43RjLwpgNKy8/mu9yGNp9X9cqye7nfFihWF33xOa8zixuISud4iT5Zy+MufMcYYY4wxxlQADf7ypyMKGZE7T+R+qG/jQOkoVUbkTqgjVxtbP3KAjMoUoSMWQDyasO+++ybTdVLOjMi5MSKqXx3JykjVWZQXHdXJSJW/HNEXh8itNWqnVN1E5Y/6QOSOGrl6Ru0RTbwZubKmXEajdaPzQEeEMnSkOCMqU+RiGznTpvpBtG8docuI2jp1HfiqRF+uuP54BJZH9Lid+LzQ/PP/eOSNRzd5xI7PAR61jFxT2dmN+3I0aS5ff/j85HbSftUQ91jOX+QUGJWT883rc93zsfic4q9K2kf4+sD/4+2jr0mczhMJc7txXfK2UV3yttzH9MsJt1fUT7hsvD5ft7gueX1uHx4N5+sMn8vR1zC+nuj5zOcTj4pzffCzAKdz3+VRc75X8cg190/OB9cLtwmfu/qlkPPE9R25P/N9hesmeuYwxpgtEX/5M8YYY4wxxpgKwDF/xhhjjDGbGP3iz1/JVZmhigxVtfBX0cWLFxf+p3O3chyzKmzKzR+ov1XNUy6+VWMWVXHAX+xVDaN1wV/r9TiaX1XK8FdojaPSL8D61Z7z2L59+8L/VDnF5dW5q7XetC74q772EVWf8L5U6bWxefI4pk5VTKoQ4f+r6ku31Vg9LoPGemp7sSJE61/nOOQ61jhKbY9y+9J58TgmFij2R21LjSnl+EYA6NSpU5gHrQtWwKi6QPuq5pnXb6yKEfDLnzFmK4EfYvgiy3I+vnC//vrr+TJfPPmhS296fMPhizPfzCPTkcjkhKVqLDvj8rzyyiv5cnV1db7MRhx8wypnkMAPDyyf44dLrid+wGAZIk9YzTcmzjdL/ngdTucbL+ctklgDxZsm1z0/+HEf4EB7frDUG3tqn9w+vMzl4Xzrg1AkleX+x/XKfYz7EueJ2zqSiXL9cb3wgzOvw+lsQgQUZZncjyO5byTR5Ac/LgOXjc+NlStX5stc9/xAzFJXfemJjGf4mhCdr5E0XR86jTFmS8OyT2OMMcYYY4ypAPzyZ4wxxhhjjDEVQINlnzq3RYZKXDIiR8OU+1/kIhk5ckVOeZGzYOSKGDlGRu6HKZe8aB6iyFFPNb8ZkbtkY503o/ZIuTSqzjkjqscoL1HeI0lVpEtXfXdGSsKm86VkTJ8+PZn+L//yL8n0aH6UxpaJYyoYnYsGKJ33JiPqd1E/VU14RlSmKO8am5GRcqzVeWsyVI+eoTKsjFS9fFVY1sXnJUu5uG/zNYolXrxtOekhn1ORdp/XYekdX9v4+sTLnCeWpXIcAcv8ov1ov+LzjKWHLMXk7Vkix+XkOJzousPwtY+35TbhuI1yc2PxtShyw+XrDF9D+NrMddO5c+d8mecb5OPyPrn/lJsPjKWRfN1u1apVvsx9l8vN9cHr8LnPbcL75/VZbsntwP2bpb56zeX9cv/jdogcOyN30Mgpm/MdzWnG5efzTe/HfF2Kzhsud9Q3omtkY9F4oXKuvHof5nMVKF4T9LrM83wCxeuNxlxFDs4ZfK5qbJHWSyQjB0qvpXwd0mc0bUeNmePf2o9UrsttqvGOuq3+5vJpXKXO98jl07nhNDavXJ3rXINaN5xHvUbqc6c+I3Dd6LOoxpzxtUef/fSaq3nk+772RX0+4brQ/qV1zuXVZ2Btu3bt2hV+c93oeajPRhwaoM9fWm/aD/g81Wc9PSf4OPpeo3Wh5eX7j95zovcvxl/+jDHGGGOMMaYC8MufMcYYY4wxxlQAdvs0xmwVqKQigyUrkbSWZVO8vspzWDrG8g+WWSxdujRfZjkwS5lYTsSSGZYzsSyKJTgs8+M8RI6TKpFmeRJLcnhfLAFimRjvi+UuLDvhZZY2RlJqlrtxfau8hiUyXH+8X5XOZXC7sVsqy6BYmsUSIZZOcVuxdPCFF15I7h8o9jmWS7GsJ3JXZbhsXH5ua5ZTc165f/OxIhmmyvmiSeW5X7LEieuP64PlVbxPPjb3T5aPsYST65H7m0q/+Bh8LnKf4e25P3C/j0IhviqcP53OQK89fC4B8TUBKJUDch/WcA+2pgeAV199tfCb21IlfBqqwX1dz1+VhnMoke5HpZvlrOyjEJgMltOpfFTbVe8PKt9kyk0pofci7Zcqy+N+oP/TtuW60ePoulpv3KdUhqt1zn1I+6L+Vjkt50PzpBJLvtdo/avclPel9aRtWW56EJWp6rkVOV8DpSEu2ke4j+l5qJJrLq+WRx2XdV+RfL+h+MufMcYYY4wxxlQAfvkzxhhjjDHGmAqgwbLPlPMfEDtGRqQcviIHwchhK5p8NZJ0Rc43keNSJB1KuTRGEp3omJFDY+R8Fu0/cteLpG8pyVUkw4rSI4fGSJJxxx13JNMPOOCAZLq6JmWo4xMQ95movtTJKiNywGSJGdNYF9dUn1HpSUbU3yPJUeTAqxKGjaVHbqIsK8pQ2UJG1H+j+toUsLsX1zGfcyxb4jbmcvE5xHJBhY/B27MckMvP8jK+xnD++LrBsg+WnvD1j/PAfZ/zo5IQdv7jPsHb8L74/I5cR1mew+cal5/7SORWyU5wen3mew1f67kMkSMk19mSJUuS+Y6cF7lNuG/w+pEjKlCsS74e8LG5bCxPZNdRLgPnj9uX64LzxNc5dqOLyhndY4HidYqXuW6ifszPESybY9kY39u47vg6yNd/XtY+w/2E+zf3M64nlgjy+pHzuDHGbIk45s8YY4wxZhOjluw8qMOxwkDpAK/GKfHLqQ6y6eAzb6uDtTpgqoON/GKuA+w6/QTnWePAdHCTB3t1vzqYGE3vBZTGC2o9cnl0EFiPq4Pz/NKvA4E6IBDF8wLxNFkZ3C9WrlxZdl0ug/YJbTvtF9F0LEDpYC+XTwfJdQonHRTmwSPNk54D3E/0w4vmiQd6tN9qHet0ITzAVi6WEygO5mvf0/Jon+G+qx/HdNty8aj6AUIHFbluoo8V5bDs0xhjjDHGGGMqAL/8GWOMMcYYY0wFYNmnMWargOUyu+++e77MEhSWmHA62zdzXJLGlrLUJIorZPkJ25BHcaocK8WSHpYO8T5ZPsUxTiwLYUmPSnJYDsP5YwkR5yOK/2KJDtcry5/42CxF43VYTsXrlLM85+Px9BMsO+NYOG5TjqPjNmS5DtdRVF8sDeL9a9x1+/bt82WWAXEd8zYcl8rrsNU391eWUXF/iPo99ysuA+dBZXdRTDPLvyKpFOeJZXZcNpYP8nkSTbPx2muv5ctcLyo15LJyf2AbeN6+TZs2+TK39T8ydtkYYzY1fvkzxhhjjNnEaIwZv3hq7JoOIqhxUzQXJ1Ac4ACAtm3b5svl4g5TeeTYIp0TUPPIAzk8AAeUDiLxi73GA2o8Fw+gAMWXcc2vxkpGczoCpTFYWsdcHq1jXZf3pXPMKTq4woNQ5Qy6gOKghJZV54LTeRl5kEVjGLUfcPvocbR8Gl/HAzjatrouxxNqHvS4bE6n8YE6QKUxcny+aP41Zq4xgz1qmMf50LbTAU1u643NcahtWS4eVa8lKRr88qcHztCRtgxt4HJEo4rRxIXR+hGRw2bkYJpyOQRKJ/UEYqdLDcTNiJw0o3qMGjFyhowCi1MuoHqiZURup1Heo/306dMnmT516tRkev/+/ZPpHKScEdVv5Pg6f/78ZHpUv5FraNSXFi1alExn576MyEEy5QwKxOdB5PgaOfBGeWeXTCblJhrtI+ozEV8mQNkYY4wxxnw1/OXPGLNVUF1dnS/zaBy/sPLoLA/msPsXW9PrS20k7+TBGx4hjqbRiF6ieVCH1+EBr2haDZbX8WCdDp5ENvk8Gsr74pFmLnMkw4wGVKJ65cEjzreOvvI0BtE0G1w3PNLLMkl2GYxkn7w+l58HVrhN+IuCDkzxQAe3Kfc//irC9RH1B84rD3g1ZAoRPi6Xn88NHYzkwTAedOKBrEjWzOXhgaxIQsv75DxxXXAf4/LroDPXE38V4QFebms+RjTlRDToZowxWwp++TPGGGOM2cRECh+gVLWi87Kq2ofjKnW/Kv/jgQBVXfBLeGpbjutU23uVtfFv3a8OeEXzZAKlA0j8gg7E8dZAqcqJB790cEDt9bUeedBEB6N0ECBSYwGl8lJdN4qFBUrLE8V/A6XTRGj7cPlV8aNl5zbRgR2tC80jSzlV7tu5c+fCbx5Y0YEz3ZYHbVTlppJKnfOTy6AqNj1ONKAIlLbPrbfeWvh93HHH5cvRnM6pfTdGJq15TKnjNobdPo0xxhhjjDGmAvCXP2PMVgHHXfKoJo+QseyM5Wg8sszrl5O/8Ugir8cj3jU1Nfnyiy++mNw2kurxqC7nmyVyPOK333775cs8Aqwj8DwqyyP5PCrM5eEvAbwtmzAsXrw4X+YRy2h0n9eJ3Bp1xJXrnuuMpbU8Is2jrrw+yx4jGSuPZPOILPcZrjuO19URaXYj1a8qqfxxHfAoM+ebvyRw+3Kf4Xh0rm/uYyxX5T6pXwwYbhfufzwqz/mI3G/5GLzM++d64XN04cKF+XLHjh3zZR3R577BdcASZ5YBcz64fdkF1BhjtnQa/PIXGYmoe1JG9Lmz3KdxZc8990ymr1q1KpkeSSqivEemHpHTT8o0JZUGxCYdkW169NmWHxyYyGAjqgP9VA2USikyGmPWUy4vKbMTIDY8ifKeio+K6jGKh4oMYqK25hgwJqqb6DxIGdCoHCEjyrvKGTZG1JdSBi5AqZQnI/WgGuUxIjKKSvVHoPF9zxhjjDHGNBx/+TPGGGOM2cToQB4bCOnXVh1Y1gFGHqDUddVoigc/y8XepY7D+dLpDnQQNvraDpQOtvNx1cFd1QrlplnQetPYKS67DvbqoLDWBQ9SPvfcc4X/HXjggYXf/FFC60Vj5rQ8XFe6rQ4gRyqB1H61HsvFnGqfYTWD/k/rSQeFuZ9r7KoO/nPd6H7Upb1Dhw75sg4s67b6Aeayyy7Ll0ePHl34n37Z576qsZHPP/984ffkyZMLv7lP/eIXvyj8b8GCBYXfPMC+sUH+xkxhEplvMX75M8ZsFbB8i28EfJFkKRzPhRU5YOr0Lix15IeoSFbIF+UuXbrkyzzfkpoBZPANlo8VyVJ54mu+kajygeuD/8c3y0iKyjdylvnx8Th//ODCDxP8AMAPwNHk6kDxwY0fkKLgfN6eb+bcB6L5tXg//GDK5eT98MORPhhFk6rzF/eoL3GZ+UGO88fLfGxuZ657dl1ldQ3XkU47w/nmNuWXjsjJlPfL5iHcB6I64vNn+vTp+TJP08QKk3JOq1xulopyGbgduf9E7rzGGLMlYsMXY4wxxhhjjKkA/PJnjDHGGGOMMRWAZZ/GmK0ClrmxRI7lfJHLJEs9WQbGMjWgKP/i/bI8LZpgniWTLCljaR+bMHHsCssNOX8seWQzLZb/qXkROx2yvI9jClgOyvmLJhTndViGGMlKI0dHrkeNT+FjsKkRSwxZSsltyu3IfYP3yfXKyywljBxLuX009oTbhcvE+Y5ks7w+74elkVx/LLHktuIyP/zww/ny97///Xy53HxuDJebj9epU6dkvjmehs8Nbh/uG9wPeX12s+X4q4MOOihffvXVVwt5ZWkpO7VyvBAfm2XA3MdYIh4ZnDUEzgNQ7O/spAsUpalAab/iutH20vghrmuNudJ5/1RuzfJujS3SWD2Ov1PnVZXO8rb6P43j03jB6urqfFlju3RfkbQbKK033Zbj+LQ9dFvuF2qWpgaIkdlgCjVH42uWxoHxtR0ojfnjfW0sLpH7o8YSauykGjnyvrSs2md4XY1vfPzxxwu/+dp17rnnFv6n59YjjzxS+M2y71mzZhX+N3jw4MJv7n987gOlsZ/HHnts4TfXq9YLX8OAYh/S9tC21DZoSFxfORr88he5V0bOhXril0uPnBK1435ZojxynAETOWymSLk5AqUdMSOqx8gBM3I/jBo+2o8GQQOlJ2FG5KQZObVG8RBR+0XrR3lPub5G9RK5zHI8FNO2bdtkugY4Z0R9VWPDMlJOs5GN+uzZs5Ppd9xxRzK9a9euyfTjjz8+mR49tETnKt/0MyIH3shNNepjdvU0xhhjjPnHY9mnMcYYY4wxxlQAln0aY7YKokmw+atk5P7HMin+mq9fdFlFwF9wWX7DX1Ij50L+CstfQTl//BU7+rLKkhSW9PD6+gWeratZ5cBf/COb70iGGC3zV36WQrGkJZpcXh0nWSLDx+B2YBdIlhtxm7B8buXKlfkyy/y4LiMX1Kic5ebC5D7AyhPOB8PHZptzbiuWpkUTp3NeWQXyyiuv5Mv8pf+AAw4Iy8DnB0s6uZ9xv587d26+zHI9ZsmSJfny008/nS9zu3GennzyyXyZJ3znYwHAkUcemS+zVI2XuZ74vGElCvcrY4zZ0vHLnzHGGGPMJiYaxAFK44F0XY2z4kEZjevVEAqO39IYMh140FjbVOhCBA/kaLiN7pen5tE86ACKxiVGMdZA6QADD3DxMYHSwT0N4+E863E0xIQHKqIQmQytUx540fAMLTsP/Gg7a0iJ1iO3iU4xpP2LBzwOO+ywwv8OOeSQwu9TTjml8JvrRkOUtF9fcMEF+fK4ceMK/9N+/cc//jFf1jn0tM6feuqpwu9Bgwbly1GoSwaHbekcmjrP3/Dhwwu/J06cmC9zjCIAfO973yv8Zh8A7RPqN6Bwe0UhbOWw7NMYY4wxxhhjKgB/+TPGbBWwrJBH0VjmxiO9LE1j6Vwk4QRKR0czeOSWR2ajCbjZuYtHvXmUlyV/LKmLJIk86ssj1lw2hUeZebSW88THY3kjj+ByOo+acv7YyZTLw2XmemFHRv1f5CjKI+GcJ94Xty/XGa/PslSWyXLb8lcCzoN+TeAR6fnz5+fLL774YnL7pUuX5ss//elP82XuPzwqzPnmEWDeJ7vb8cg1t8/JJ5+cL+uI+4MPPpgvH3zwwfnys88+my+zeRbX91133ZUvX3zxxfnyX/7yl3yZz93DDz88X37mmWfyZf7aw1+YeP+XXXZZId/R+cd99PXXX8+X+SsF93s+hzY2Im+MMd90GvzyFzkURu6KkdMjx1VkqC1xRvSgpZ9hM/hzK3P++ecn09VKNSPKu8agAHF8h9rBZnTp0iWZHu1H7V03RuTGyDfpjL322iu5rsoMMqJ655snE8WNdO/ePZmun+kz+vTpU5KW6kdA7HR55513JtP5QaYhRO6uKqXJUOtxALjqqquS60YOrsccc0wy/b777kumv/nmm8n0X/7yl8n0clIkJeoDkcwl6kuRlXzKldYYY7YG1OWYB5f02qrPJ7otv4Tqtvo8wQMB6uat8kyVHS5evDhf1nu3bqsDNow+y/AgiQ6y6T1Jnz95X3rv1TzwYA8PrKS21efZffbZJ19WiaW2B993Nf96H9T7ZTnZnk6VwG2p7ay/9VmW217vtdqHoilxgNLYWn1GYemt5l/rhiXJ2uc5phgoPn/Nmzev8L/999+/8HvRokWF32eeeWa+fPvttxf+p67k3B/VnV7zeN111xV+s7O8SjmPO+64wm+u441NvaFtwNs2RpqdYdmnMcYYY4wxxlQAln0aY7YKOCCfR0Cjr8Q8ws2joDxypyPB/GWdXQbbt2+fL/OoLu+LR5l5lJVH7Vg+yuuz6oBdSnl0kEcOOZhfR3R5JJOlmFwfLIvj+uNRXJaGcv44H1y2SD3C8LH0SwFLA3mUnY8XGQ3wl2aWD0bySYbLzKOtkSmAGk489thj+fLVV1+dL//Hf/xHvswTpD/xxBP5Mrtg9uzZM1/mvv7CCy8k1//Od76TL/NI9qGHHpov8yg2f33QOT7ZNIP7PbuF8ig9G2vwqDrnm7/CsNSTv7DwXKb8hYC/HrCCRb8gRS6vTKS44P6tXyCMMWZLxl/+jDHGGGOMMaYC8Jc/Y4wxxphNjMbtcMycfqFX0x025wGAZcuW5cv69VLj0fjrq34B5S/YQOlXX46Z0ykZdP5DLp/mVz0Tork+gdIYOY3VY58IjdvjL/v6e2NxbhqLznGJ6pGgsYXlbPtZYQGUn5JBY79UAcFfzzVWUOPrtK25nrXsGovHChb1qhg4cGDht05p8OMf/zhf1ik+tL1YfcGqFqA0xrRjx47hMSdPnlz4XVdXV/jNMYGaJy071xMrK4DSmNjvf//7hd8c13fTTTcV/leubfXaoG2p5ymrEdTUrSGmVH75M8ZsFfADA9/Y+OYfyS35ps8X98g8Byg+cPFk63zD5YswB6uzfJAfZDhPLHNjOSMv882DH6Y4b/rQwhI+nluMy8p5jeag4gcpfgjhQHuWyfLDBNcRPySybFHNq/hhN3pg4LrheuW+wQ90XE7OE9crP6DzPrkN+bj60Mvyy/79++fL3NZcr1x//JDF7cMPJCyV5fzNmTMnX+aHN66Lm2++OV/mcurDELf15Zdfni+fddZZyWPzvvhBlx/i+YWE+ys/VD/66KP5Mr9ofPe7382Xb7311nz5z3/+cyHfvN9evXohBeeV8xRN/v5lzBWMMeabRINf/iKXw2iyRJ1AMkNHZYCNT4ipRC6g7ErFPPTQQ8n0zp07J9MjB9MU6hKUMWnSpGR65Nyokz9mqJtWRhSfEtUNxyRl6ENKhlqVZ+hoSUbkVBVZzLMlOJNyxgSKo0gZkVskjwwxkYMrj2oyOvqZwXFHTFRnF110UYPSgNKJUzN0ctmM6GHmwgsvTKZHMVdR3lPtGj34RNeHqJ0a62JrjDHGGGO+Oo75M8YYY4wxxpgKwMPvxpitAv66y18WWbLF8jr+qs7qA9b7qwqApW18DD42ywf5a2sUD8PpvE9WT3AZeH3OH8vi+AstO44CRRUAx6LwMfjLN38d5/1yPqLYGN4nuzjyV2WOI+L9q6okckvl9bjOWJXBSgkuD8t1OSaJv1jzXF9cHu4/rIpQtQaXiWWI999/f748Y8aMfJnbkeuJy/BP//RP+TLHkfDE8VxH3M7cZ6K2UgUJKx5Y0cFxNKzq4TJz7BpLjnn+1ilTpuTL7PDJ5yvH1vB+zj333HxZY9B4Qns+d7nOIqkn1x8va8xPY9A4K65nldqqSkpVRiz33VhMGZ+f6n6syhLdlvuzSsh1LjWuG1XVaPm4X6gShF1kgVIJOF8LVMGkihW+PuhcfRp/puom3peGAGg98nG4fwKlbrHattH9IPWbz0WNO9S4SlU8lTvHNT6QrxOq7NHYSY1HYym2zrOtcW+cD1Xjafk4TyNHjiy7rp6nfA7ofV3j67iOdR5rnatPFVt8P+PrNABcccUVhd///u//ni9r22l8rZ7jfI+OFILl8Jc/Y4wxxhhjjKkA/PJnjDHGGGOMMRWAZZ/GmK0ClriwfIflOSyvYakESz15P2zfDRTloSzdYQdFlv+wzIYliSx9YSkgy2dYeshyMS4bb8t5Y0mImj3xvliexEZMvF+WyHC+I+kVy+s4nWU4XF9cHpZWqf07y3p4PZYhsjV4VDfcPiyl4/2z9I3LwxIgloRxXlOmZhns/Hn77bfnyyNGjMiX27Vrly+zgyvX91//+td8mfs3H5sni2epErc5yzO5bGqxznLKAw44IF9mORj3Vz5vDj744HyZzzku589//vN8mfsnS6HY1ZW35XNMzeNYWshl4LJyvbI0TPvf14Huk/uummmpPE6vRSwDVoM9lfvxdUUleipnVFMzbmM1cVMZKF8rVKamJnXcbvo/diEGSmWgnEctu0oUo+slUCoDVcko9yc1FNx7770Lv1m+qJJQdjEGSiWWvC+9fqg8k/9fTnoKlJbn5Zdfzpcb09/0HvK3v/2t8Funfnj88cfz5d/+9reF/5166qmF33zf+ctf/lL43xFHHFH4zf1EDQIj874Mbnst+0svvVT4zfWmctJjjz228Juv0UBRRq19RM9/vidq26lEXM9/vrdGBpvlaPDLX2N17pEbZcphUrWuGVr4jMhdUnXVGdqhMvr27ZtMj+zd9YQFSi+kGZFbZJQeOWlGLpVR/ap2OUPnKgFKNfgZbKPNqO4+I3KLjPpM5AwZ7SflAqrzAGVEDqaNbY/oZIqcaa+77rpk+rBhw0rSdM6cjMjVM3LUjXTeGseQoRfsjG7duiXTU+2hN8+M6EEp6gNRPzXGGGOMMZsOyz6NMcYYY4wxpgLwy58xxhhjjDHGVACO+TPGbBVwbBbLpVmqyzESHKPE8Q4cY6HxL6z/Z6k2b89ydZbJRrJejjtjqS3Lsp977rl8mW22WTLPeeB8q7SZ98v74vTIFpslxSzfZrk1S9K5TRiOk+AYtIcffjhfrq6uLmyzdOnSfJnrY8CAAck8sRSZ2537A1vMc155me3sOeSA5dhcfrWtZ4lz1HacP94vr8P9imNUBg0alC/PnDkzmVfuAxwHx32S4+BUxs31cdZZZ+XLHPYQ5ZX7DB+b1+G+x8fmc5GPxf2T21zjlqLYHd4Xy+c5FojPyyj8orGo3J3LqmEYeu3R//P1p3Xr1oX/afjDAw88kC9rGIyG17D9PFCc6kTzz9dQoHjua2iGhrZwf9N4LY1705g5Pl84jhYoPf8WLFiQL3P/A4Bp06YVftfU1BR+c5zoo48+WvifhiuddtppYf41FENDOcrFP+q+uAwaV6l50nsOh+5ovKPGbzKaf53KQmMPefqVU045pfA/DZ3hc1GnYNA+z7HY2vc4dhAovYbxcbVv6jQqHGqk576el9o+XMd6/+vdu3fhN1+TNKRG4wW1X/D6GncYhf4w/vJnjDHGGGOMMRWAX/6MMcYYY4wxpgJosOwzcpeMnBv1M3BGyo412kfkZhg5MUbSjMhJM3KXjD5/s0whY+XKlcl1WaLE6KfqjMjxNHJFnDFjRjI9cjb913/915I0tbDNuPvuu5PparuboTbAGZHk64c//GEyfezYscl0lXEAsbukyl8yVEKWwXbrzEUXXZRMj9ovau/jjz++JC3q15HLbOSYGZVVJQwZahmdwVIKJuVsmmoLIO6nUbrKb74OoukGWMrFEg1eZnkJS0L0msL5ZikdW6BzH2F5z8KFC/PlQw89NF/mOuLrLLfjD37wg3yZr1ss2eJ+ws7Ey5cvL5ShU6dO+TLXAV8nWbrC/ZXrg5e5L3I78DJL8Ni2n+UtLLHU68ecOXPy5dra2nyZ+ynXAcuJ1qxZk1yf65iPx5Iavh9E9cX70fOG24Lrlc9Hrg/uPyzf4eNx/4mmdOD7Km/L6WwfznlTF+tly5aF/8uInhFYOsfyJE7nax+fr9zXuX1YssZ1pE7gfM6x5JbrgJ9VuP9E1xNjjNnSccyfMcYYY8wmRucX48GhcoMGQOlAWvRCDwC/+tWvCr95eqF+/foV/tezZ8/Cb40f4rgyHYjUeEF+kdbBAI3H5AEWHYj+/e9/X/it9cYDlg899FDhf+edd17hN8eRXXHFFYX/de3atfBb88zzafLACgA8+eSThd/z5s3Ll3X6JI3x09g2HvzQeC0dbOGBSh0A5kEuoLTeeGBJ4960f3H/03V5UCUFDxjqhwedFovjl4855pjC/3RgmttL4w714wQPWCk89yhQWnYeINU5J7XsOpDN7cMDXED5OQE3Nq+olpf7UPQhoByWfRpjjDHGGGNMBeAvf8aYrQIeOeNRPx615NFyHjljWRePwKtT5rPPPpsvP//88/kyj8rxKBw7MfIoLLtV9u/fP1+OHEjZ7Y7laDzCPH/+/OSyyrJ5dJjl5iyl45HqaJlH+VkOySPGvH91psvg0V3+sqAjrCeccEK+/Mwzz+TLr7zySr7csWPHZP64Lrl9OE88Wh1J4nlUl2Wb7dq1y5dVZsvucCwPZikv9w0OjeAvK7wOfx1gt0M+B9q0aZMvc9tyOrcnhzVoOANvw3niOuC64dAMPgaff3wMbncuGx+Lz9GobdV5jx0A+atO5ITK5eFzMQrLMMaYLRF/+TPGGGOMMcaYCsBf/owxxhhjNjFqVscxQGoEpnOcqZkNo2Z0GgN0xhln5Ms6n5gagakpH+9LDeU4lhAozo+mX/p5vkCg+JVazd769u1b+K2xYPxlXuMDNb6OY7JYuQEAI0eOLPxevHhx4fe9994b5knjLPmrs8ZCah1rLBvnUdfVWFDet/YZbVuNYeQv4RofqKZG/EW93Px0QGnMHJeve/fuhf9p/CDPn9irV6/C/1R5c+CBB+bLGmunigs1p2NFivZxPS4reXQ/rIIAStuS4/g0xk/NJ1mVU27OTKCoLgGK/UC3jUwCmQa//GngaEbkFBg5eKYuYJGDYLTvyBVRg2wzIvfKyHUxCma94YYbStI4yJfRhsrQi09GVF9ReuRSec455yTTUy6rUYCpXqQzrrzyymS6BlFnqAQnQyfjzIgc1dgBMCPq3FGb6gUoI5p4WydAzdALTIZeSDPYlTAj5aIJlE7MmxGV9cUXX0ym680vQwOXM/QCm5GaKDSSw0VtpxfKjOgci/LYEDhvfGOIJh1n6RifZ3/+85/zZZZnAkWJHT8oHH300fkyyzi5v/CDH98UOOCdg+H5XOZ8vPzyy/kyn6tsQMCmDtofuD6iuuFrMp/H7AjJ5ee65Jvsa6+9li+zJJNvVnydZ2dN7d9cJjZf4OsDTxJ/5JFH5sv8IMrl4fsau0Hy+vxAxQ6nfB6zK6U+3PB6XD52OeV1+BgsTeY24fsoXzf4+sfl5Drmvsd9kutCjQoY7if8kMR9kdfhMrAEluuYy8bOqfwAGt0LeR29ZnE/4/Jx3+V253qKrsfGGLOlY9mnMcYYY4wxxlQAln0aY4wxxmxiVNLHX95ramoK/1NVis5LzIqQDh06FP6n8jI2wFJVi0pRVSXDc9iq7FPNpCZPnpwvn3TSSYX/6fyzvK6qgQYOHFj4rRI4LrsqxHjOTKAoWz3ggAMK/9M61vmp+Yu8qooOOuigwu9o7kn9X2pfLOHjr+NA6VQPrNTRKSP0OKzUAIpf/TWP2j5c5507dy78r5y6ASiqyrSONU+DBw9GhMpnWXmjx+Qv+ECpSotNm3T+Xq03Vi7ouaQSV1XQ8fqq2lI1HKsZyk0DAxRNzoCiqkynUWkIfvkzxmwVRBPH8w2EL8x8wef4Go5v4Mm0geKDEj9wPf300/kyP6TxBb1Hjx758i233JIvsyydpY0zZszIl4cNG5Yvz5o1K19mSSKXk2NVvv/97xfKwHE6XB+8PdcH39w4tojT+QGM5bcsc2SZX+TWyHOO6UMp33RZ3sll4O35QYfriR+YuH1Ywsg3f35g5wcmlhTyA5lKnVnSyHXD9cf75fX5GJwPzh8/yPC2/PDA5ee88v6j9tffLOvlc4D3FclYeVs+X7mtOayDy8Pt3BCZLFB8EeDjRfFzXMdRnzHGmC0dyz6NMcYYY4wxpgLwy58xxhhjjDHGVABf2e1TdcIZqqnNSLkoRvuIHAQjR0d23GMil8r//u//TqbzBMlMypWU5VhMJEH73e9+l0yPnMxUY58RyVai47JULOOFF15Irhu5S44YMSKZHk2AG+mQVcedEfUxlX+V20erVq2S6Sw3YtQid2NEx1VdeLn9R/1X40E2RuT2qXbPGZHzJsd0MBprAMRun6k2Akr18RvLy1eB3fm4D/O1iM8bbhs+t3lbdcnl8kSSRs4HOzpyOstEv/e97+XL7FB566235ssqw0vt8+STT86XeQLt//3f/y1sw5I5joHhcvN1muuMJ5vnGAu+flVXV+fL7ILL/YnPI96WHUFVasdSUbZd53bkOJVISsgSS64Lvo5Fckheh8vD57/GILH8kmNlognmeR3eF/djbh++f7KUlPsMx91ELs/RfnR7vq5zP+O8cl/iuuE25Anvef+8DrcP75NjZ7ifaEwNy1L5HsD1xzFW3KbsCMrbNsRGPULj9vj6oNdWjXOLnpOAYjsApefOmDFj8uWuXbsW/nfEEUcUfmsdcvupA6pO0cCya30W0Wc/vpbqlBH6/KjPXpEUGyiNKePzV6fA0Hg0zTPHYZabCgEotpc+D0TO9Rl8zuszg7rbc//TKT40ZjG6XwOldaxty+eCPp/q9UGfATneTp/JNCaT7yPlYgeB4jVdny20f2lb8jmsZdXj8LOo1r/GFrKjNVC8/+kznT4/ch/SuFdtW3VC57CG1LPaxvCXP2OMMcYYY4ypAPzyZ4wxxhhjjDEVgN0+jTFbBSyHYUldJLlhmQ7LpHh9lbuwPI+lLiztY8kLy39YdsI24Sz94m1ZtseSFpYIseSEZS4sV1W3TyaSwrHEieuAJWMsxWKnTJbusHyGJS8sf+N65HVUXsP54/ZlmQ23KcuZWdbDx+Z257bl/bCkhtfnumc5mUp0Oa9cJpZD8TYslY0kpywXYvlx5CzK0kbeJ58z5WTnkWMnl4HXiWSz0YTsfM5x3+N+zG3C+WYJVznbf64nlo9x/rgMKvk2xpitBb/8GWOMMcZsYnRggAc0NBZc5/nSWEMelND4M54PDSi+2J999tmF/+m8chonxoNKGr/1f//3f4XfV1xxRb6scW8aS8jH5fhPoDSOT+vmkUceCfOvx+UBEfVKUC8Anb+uV69e+bLGVWqcIg/cafyZxm+qv0E0uAKUxvDzABQPaACl/UuPy+XX+DqNoeP20oE47Zs8fQwQT8sClMa2cV2pd4DGP3IcnMZvloun031rebTOowFMoDjQmcoztwHH5QGlMZlRXDZQWsfaD/ic0DpuCA1++dMTNyMy0tATMiMVgBoFUEdmHNH6GpiZEY38P/roo8n0X/7yl8n0448/viQtGi2NTGOi+orMbfSCkxEZZjzxxBPJ9Hbt2pWkXXDBBcl1tRNmRCOhs2fPTqbrJKgZekHK0MllM1KmN+edd15y3SjvHIjOPPbYY8l0DeLN0At+Bs/hxpx22mklaTfffHNy3VQbAaU3xow5c+Yk03WC3Az+osBERjup8yky1NGLf4Ze7DKi/m6MMcYYYzYd/vJnjNkq4NFTHq3mF1N1+cpgaSMP0OjoG49I88s0j8by4AaPMPJLPA+O8eAUp/O2POrHrsYsBeTRPx4E0sGyPn365MvsIMjr8cs5SyafeeaZfJkHQng/XGc8OskjyzzgwAOCPMDEckmgWL79998/X+a2i6SE3O5cl3xsLjN/LeB+xXXBroKRszFQHBnmkd5IdswDipHklJcjF0w+B7h9WPbK6TxKrQN9PMrO7chtzecN1w3Lb7m/cpvwMueDzwEe2ecvC5HbtOYv+sLAfZT7Bp+Lr776ajLdGGO2RGz4YowxxhhjjDEVgL/8GWOMMcZsYvQrZTmVgcbxqDyfQ0I03mmfffYp/F64cGG+rHOCaayXxszxl2+dQ09j6DhUZ2MxSz/60Y/y5SlTphT+N3ny5MJvno9U8/zd73638D8NKeA6/8EPflD4nxp66W+eW02/+Gq9cUiEhrZonWpMIysHNL6xXIiE7lfnq9PQjXLxdRqiwXnUODftQ9qvWVGgoVEcGwkUDc80NKXcnKkbmxdZzxc+n1QBVG4uQs2D9nmNs+Tf2mf0POXzSc8XbR9tA26vaJ7pcvjlzxizVcAXe77J8UWVJXJ8IeYHE75x6w2EH274ptypU6d8mW8c/NDCN0yezJ2PwTc0jt3kGxc7bvKDAse7/vjHP86Xyz1U8v/4RhVJ+1huyen8oMDl53plKSHLKlneyTd/fQjimyE/LPG+uH05bpfLxjJgflhatGhRMq/8IMMPhyzj5QcCfbDj+ohitRmWdPKx+aGC65XzxGXjhywuP5tE8APFvvvumzwWUJSK8kMHp/P5wOcf928+t6JJy6NJ2/nc4PbhBzl9KOW+zg9aXH9cT9ynuY9FcdHGGLMlYtmnMcYYY4wxxlQADf7yp6PH+Q62Se+CpQJMagQtcuPkUcWG5EU/2WeoJWxGv379kum9e/dOpqecJCMDCbUMzoicSufNm5dMP+KII5Lp9957bzL9rLPOSqbrSC4ALFu2LLmu2gdn/PWvf02mz5o1K5mun8czampqkunf+973kunjx48vSVPJRUYUjN+hQ4dkuspjMiJnzGj/p59+ejL91ltvLUm76qqrkuuqJCUjch494YQTkumdO3dOpkdOqPqFJSNV1khqEVkNRy7BUV5UVmSMMVsL+kwTmQEBpQ7Kej9lqZpef/X5484778yX2bwGKL3f85dXoHitZrMooPSZgL+8qsRNf7PlvzqPP/zwwygHS0b1mUod1RcsWJAvswkSUCqX06/RkWoEKL1vRvNwAqVtq/fF6Ks2UCr3Y7WCPjvrc4v2GT6u5lG/mnOedGoEfe7Xvsp9SN8FtG+ygkLloypb5fJoW2l5UjMLpPYDlOaf61XrWPOobuy8L6037W/RXL5A6XuOPhvxM3A0i0A5LPs0xmwVsHyQZV18geV5gljmxhdevpBqnArfPFnm1r9//3yZL8qRCybvlx+uosEFLhs/HPCNlG8snDd9eOAbMz9I8GBQNKUHl4dvipy/KBaB64XzHTmf6sAaSwb5f1welljyTTpyc+W88n54He4bXPe8zO25ePHiQr5ZBsp9gAd1OnbsmC9HAyyczsfjuuA88cNCNF0Mtyf3Qx2k5X7CDzf84sB9gNuKX3D4QZDbms9RLgM/wPH6LL/mdtbpoSInVK577utcbn5Z0QdjY4zZkrHs0xhjjDHGGGMqAL/8GWOMMcYYY0wFYNmnMcYYY8wmRq34WWqr0wOoa6z+n+W+Gi+kMVkDBgzIlzWmT+PRNJaK5bYaW6SxelEsN1Aa78RTVWgcWLdu3Qq/tTwsw9X8apwYy5+1DrU8kVcFUCpD15iyyEUZKI31VBkxx4apd0XkHwGU9ieN/dR+wW1QLqQBKPYLnXZA19XfLN3WsmrsJ0uzNb5Ot2XJucZg6lQVui1L39UzQmNBWUrO/TT1W/sft4nWv57T3F7aHuXiA4FiGIDWv8YlpvDLnzFmqyCK82NTH75INsTiXW/4fPHmmxjf3PlGwtvzjY1vEJzvaC4inguJt+UbAD/IRDb/QPFBisvK6/GxeX3OH5eTHyj5YYUNCDjInh/CuB65fvXmx23EDyN87MioiW/QvD6XjffPMZMcE8b1xfFu/NBbLsifj8fb88MIr895jWIp+SGU65KPxdtyTCL3Jd5WH4ojAwTuZ3w8fvCKpg3hByOuC14nih3k87vcQze3O5eVY/ui84m3VTMJY4zZkmnwy1/kUqkuORmRg6COVACxq2fkIBi5ferbe8bhhx+eTJ85c2YyfdCgQcn0lKNONFKkoxAZUT2++OKLyfTIAZOD65lJkyYl04899tiStMh187HHHkumP/nkk8n0IUOGJNOrq6uT6Tr6kdGlS5dkOo9aZkR9QEdPMtjog7nwwguT6dEcVJGDaWSocOqpp5aksSkFE50HUf1Go6yRA21kWhDVmY6gAqUPthnqUJYROfD6YcoYY4wx5h+PY/6MMcYYY4wxpgKw7NMYs1XAX/5ZLsYafZYFsi6e1+f0cnMJ8ZdaljqyfC6SsHE+eB5StqpPzc2p5WGpJn/ZZVmgxh2wlJDlbyzP46/zXE6W9nEZuJxRvllKqbE3qbwpfGyWOnIZuD74qzPXMX/RZgVFSpUCFNuc64jTOW8aE8KyUa4nVoewqiSSILMkkcvPfS+aA4zzzXnldVhWqVMmLFq0KF/u2bNnvszqA+73rPzh/fK59dJLL+XLLMeO+if3H84f1532K64nPjbXPSsfON/cfyIlT2PRaTxYMaGxUKo00m35HNcYH42R69u3b3K71G9VZfD5ouoqVWfxcbm9gNI65L6j1wwtj6piOI8aj6bqKs6HHkfj9rQuuA1UacNTBQHA6tWr82VtKy27Ksb4mqHT7Gg8F9+TtL+n5tFmWLmkEnltd64L7Zuq3tI2iGTZqTzyNUvrWMvOedLrtea/XP/TdXXO606dOoX5VwWVxmRyP9C5+VQhVi7MQfuq3lf42hGpvcrhL3/GGGOMMcYYUwH45c8YY4wxxhhjKgDLPo0xWwUstVm6dGm+zFIlllmw9IPlMyxdUmMllqS1b98+X2YJDctyWEbG8jKW27GkqW3btvnyihUr8mUuG0sYWbbEMhd2OC0nCYlknFxOricuG5eH11+4cGG+zNIcltFxnljixRJVdjgFivIblmPx9iyn4mOwrIflWiwr4rZiyQ3vp0OHDvky9xmWVarUh/fFhkncviyb4r7B5eF1ON+8f16fZU4sEWKTNi4D9zGVMrHUibfn/sf55jzxtlxmllax3Iv7JEsOuX+ztI/ropxdOtcNy4NZpsV9jNfn+ohMvxqCGuFxudXmXmVfKn3kspabngEoSonVhEvlZir55bpS2ZpKH7ld1AxQy8750DwoKuXk8qksTyWXLFnU/+l+Vd7Ix9nY9AZscKf1pP1SHZi5DFpvKhnl/+t+tXwqo+dreWT0lhFdS4BSyahKIbneVGKpdcPXS5Vyap/h66yeH2o6p+EO2l6Mypn5mqDyUe1vfL8DgI4dO4Z55PuyHkel2orKgfnaUW46kIgGv/xFrn2R66JqgDN0fg0gdsDUC1hG5FqoF62NEbmJRvnRCwMQ5zFqSG3AjaEnc8ZZZ52VTL/22muT6Sknyaj8KVdTADjooIOS6fzAykSOpFE7Re1aV1fX4H2ohj8jutBFrpNRO/HJykSxSqkLTteuXZPrRg/pkaNs5A7KLwcNWV8vbhmp9oj2Ebl9RvUSxVcZY4wxxphNh2WfxhhjjDHGGFMBWPZpjNkq4MmrWZrFX04jV0X+Qslf21XCx1/0WUoY7YvVAvy1mmUmrIbgbflLMO+f3dJYGsnzR/Jx9et2NM8mf+2OJrtu06ZNvsxf2aMJu/kLb+SOyvKVyK1T88HLXH+sxOB6YjUHHy9StPD6XAaeL5TzWs4Zj1UwS5YsyZf5yzq3Oysm+Ks8l5Ployzd5HOAlR1c35xvPh8436o24PVYRcFl4G04r9xW3I+5Hfjc4Lrg84/rkZ3v+FxXyRznj9s0kiCzvI2Px/v9KrJPY4z5JuCXP2OMMcaYTYyGiXBYgIZbqO29WuRHccpA6UswDwBpWIuGRGjIDg9+6MCR5jmKYwVKw0x4vxqzqOECGm4QDehtLP8ab6YDY1oXXFcalqF1wXnSWDWdkkHLywN3OuDIca9AcWBOYwd10EYHKnhbrVMN/+Cya5iN1rEel/tuuakdgOKAkNaL5qldu3b5ssb0aRyi9iHOh7aPhldxrJ6eWxpfp6FsPC2O5l+Py4PAqbAyRvsQt+3G4gVTWPZpjDHGGGOMMRWAv/wZY7YKeCSWR9F4VIxH9HjEmEdQly9fntwnUDT8Yac7HoXkZR7Z41FNHvHnkUQerYwkjCw3rampyZe5nDySqWXg0e7I1ZNHfVk6x8fmbXlUkvfD8jx25eR1eKSbv1joiDe3EY+g8qgzj9yztI9HYNkQiSWWXE+8fz5u5D7J/Uq/7nA98bG5bngbXp9HxSPHTd52v/32y5e5XrhsPPLOo9bchvrFgPs954mNnqKvF/y1hcvAx+MysPSSv05EfZrrS0fheRt22lMXvozIfTMyQTPGmC2RBr/8Re6dEZGTZMqSNFo3+gyq1qoZajuc0a1bt2T6jBkzkumRJax+dgVKP2lnRJ9hU86V0b6BxruDXnbZZcn06dOnl6Sx1XZD0qN6iW6kkRNq5Eapn/Ez2LY/I6rfxn7+juo9utlHzpiRVXWqv0funRGRja9KJDIih1iO12IiB88UUf1G9diYcwlo/HXGGGOMMcY0HH/5M8YYY4zZxGgcHxv3aMxSuTkLgeKgucYS6dQ70TykQOn0RTqnGw9W6vRNGj/IX/d1IE+/ynIM3cbiA/X/PGCpg6nl5hPUwUvNv8ZKcj40PlAHTfljheZBB8I1fpDnCCw3H53mWWPx9LjaXvzVX6dpiwa2gdJ60fLo//k4+hGHDcGAYr/QQXf9uMJ1rooW/QihA8xcr5oHNf7i/Gv/0rbTfhGZYKWOywZiGgupfVPPCT4Oqy6AoiIowi9/xpitAp0U/MvCN2IlUhewTK4hboDRXKJMNO+lTkibocH/m4KNTQysNFa5wA+e+hC6KWjfvn2j1o/m6Pwy8GTATEPaMXJsZaK5NPnhv6Htw0YLjV2nQ4cODTpGiqgM0YNqpPJR/hF9yxhjvqnY8MUYY4wxxhhjKgC//BljjDHGGGNMBWDZpzHGGGPMJkYlvRyro8ZeGrOk8WqRKyxQGlvIcm2NjVLpr8Y0cRyZ5lHjkDh+UGOhtDwsX9eYMTUt07gxjmnU8mgcXDkTODWZUzkwx4lpHJUehx1uNVaN534DSs3XuK40bq+cxFuPozFzWm98HI391JjMcvvR+FMNReB9a3m0X3D/U4dn7TPc37T+tZ40jyyz1/keNcSC+4XOF6h1rOXhuFcNk9Dycdm1H2tMqV47OI5X54ZsCA1++dOAyIwoBiRyItSLFFAalJoRuRxqZWdE8QEHHnhgMj2KzXn++eeT6akgysidMMpjdMzI8bSx7pJRO/3whz8sSYvqN7pYRu6rjW2P6CIT1WUqPiOqr6j80frRhbWx/T1y8Eylp84BIHbp1JtxRuTSqcH+GfpAkKEX0YyUW2u0b715Z+iFMyM65+32aYwxxhiz6bDs0xhjjDHGGGMqAMs+jTHGGGM2MaqGYSWFqk2iuVAz2DGYpWZAqeKE1R2qJlIljipTWBKnChrNIzsuL1u2rPC/tm3bFn6zbE1VL5pHVTqxHFPzq07KvK3KJFUNo8dl1ZGWR+WMrOpSZYu2T6TmSeVRFTj8/43NGazTRmg+GFXdcJtESr4MVfiwhFEllpoHPo7mt5ycVMuu+9X2Yimn1qmee9yntE/oOaDnNCvnyrWd7uvtt98u/G+fffYJ8w8Uzz09hyPVHeMvf8YYY4wxxhhTAfjlzxhjjDHGGGMqAL/8GWOMMcYYY0wFUFUfWQ8KqtvNiNz5Ive/lMOkalkzVO+boba5G1s/0ivPnTs3mb7XXnsl09VqFUg7UQKxm2Hk3hk5PaqtbIZqhzNWrlyZTE85lUbrRvUV6csjB0zVxGdELqPR/lN1ELl3RvUYuU5GpJwuAWDFihXJ9EhLn7Lgjc6lqB6jUzRyZY36RlS/kbNpaj/l7KBTRPXS2L5hjDHGGGO+Ov7yZ4wxxhhjjDEVgF/+jDHGGGOMMaYC8MufMcYYY4wxxlQAfvkzxhhjjDHGmArAL3/GGGOMMcYYUwE02O0zcobcZZddkumRY2TKWTByYly/fn0y/c0330ymt2nTJpn+ySefJNMjJ83IMTLlJvrhhx8m143So7x8/vnnyfTI/TCqmx122CGZ/vbbb5ekRe6o0b4jZ9d169Yl06N6bKwDZGo/UZ95//33k+k77rhjMj1VL0Ccx6hff/DBB8n0lBvsp59+mly3qqoqmR6tH/WZKC/R+q1atUqmp9xBo31EzqPR5SVyw91vv/2S6cYYY4wx5qvjL3/GGGOMMcYYUwH45c8YY4wxxhhjKgC//BljjDHGGGNMBeCXP2OMMcYYY4ypABps+PLOO+8k0yNTj2j9li1blqRtu+22yXUjc43IvOPdd99NpkcmIDU1Ncn0yPAkZWoRGbtE5iVR3t97771ketQ80XEjU5bU+pHhTbSPqH6jPrD99tsn0yMTm1WrVjU4P2+88UZy3cj0JzJTicxRdt9992R61K8bY4QS1W9kYhOZ0kTt0bp162R6ZBwTtVOqTJGhUGTgEvX3lJkMAOy6667JdGOMMcYY89Xxlz9jjDHGGGOMqQD88meMMcYYY4wxFYBf/owxxhhjjDGmAvDLnzHGGGOMMcZUAH75M8YYY4wxxpgKoNSKMFox4VoIxA6CkctfykFw7dq1yXUjx8XVq1cn0yMXxchNdOXKlcn0jz/+OJm+8847l6RFroXbbbddMr0xzopA7HgaOUNGef/kk09K0qK2i+o9ymPz5s2T6ZFrasrxtVx6qv323nvv5LpRff39739PpkfOmJFDbFQHkYNpyvU12nfUHpEra3SONWvWLJke9ckoPylWrFiRTI/6QORI2qJFiwYf0xhjjDHGfD34y58xxhhjjDHGVAB++TPGGGOMMcaYCsAvf8YYY4wxxhhTAfjlzxhjjDHGGGMqAL/8GWOMMcYYY0wF0GC3z8hFMnLe7NixYzJ92bJlDT1k6E74wQcfJNMjp8f6+vpGrd+mTZtk+rp160rSItfNDz/8MJn++uuvJ9Mj98qofvfaa69k+ltvvdXg9SMHzFQ5gdhdMnL1jJw0ozqIHCBTDqmNdVmN+kxUB5FDbOTWGrlaptw+I+fc1LrlaKzLanTciJT76C677JJcN+UmC8TuqJ999lmj8mKMMcYYY746/vJnjDHGGGOMMRWAX/6MMcYYY4wxpgLwy58xxhhjjDHGVAB++TPGGGOMMcaYCsAvf8YYY4wxxhhTATTO/i9B5Oj43nvvJdNTrot77LFHct2mTZsm0yOXzsjpcdWqVcn0yF0xWj/l7NmsWbPkupH746677ppMj9wro/1ELqO77757Mn3FihUlaVH5o3rfYYcdkum77bZbMv39999PpkeOmVE/ePHFF0vSdtppp+S6Ud4jZ8zIlTVyzIwcTyMnzZRjZuQkumbNmmR6y5Ytk+mRY2bkzBsdN0pPlTVygk2VE4jPj6idjDHGGGPMpsNf/owxxhhjjDGmAvDLnzHGGGOMMcZUAH75M8YYY4wxxpgKwC9/xhhjjDHGGFMB+OXPGGOMMcYYYyqAqvr6+vrNnQljjDHGGGOMMZsWf/kzxhhjjDHGmArAL3/GGGOMMcYYUwH45c8YY4wxxhhjKgC//BljjDHGGGNMBeCXP2OMMcYYY4ypAPzyZ4wxxhhjjDEVgF/+jDHGGGOMMaYC8MufMcYYY4wxxlQAfvkzxhhjjDHGmArg/wOVUZ8UoMpgWQAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from trdg.generators import GeneratorFromStrings\n", - "import matplotlib.pyplot as plt\n", - "\n", - "# Define your strings\n", - "strings = ['Hello', 'This is Patrick', 'From NMA'] # Update this list as needed\n", - "\n", - "# Create a generator with the specified font\n", - "generator = GeneratorFromStrings(\n", - " strings,\n", - " space_width=2,\n", - " skewing_angle=8,\n", - " count=3, # number of images to generate\n", - " fonts=['Purisa'] # Update or add more fonts as needed\n", - ")\n", - "\n", - "# Setup matplotlib figure and display images\n", - "plt.figure(figsize=(15, 3))\n", - "for i, (text_img, lbl) in enumerate(generator, 1):\n", - " ax = plt.subplot(1, 5, i) # Adjust the number of subplots if needed\n", - " plt.imshow(text_img)\n", - " plt.title(f\"Example {i}\")\n", - " plt.axis('off')\n", - "\n", - "plt.tight_layout()\n", - "plt.show()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "74d69125-214e-4f79-a588-7922555270ef", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - " \n", - " " - ], - "text/plain": [ - "" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from IPython.display import IFrame\n", - "\n", - "IFrame(\"https://www.calligrapher.ai/\", width=800, height=600)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "84992eeb-b2a2-4e7a-96a8-18c9ea17e5f2", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "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.10.12" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorials/W1D1_Generalization/W1D1_Tutorial5.ipynb b/tutorials/W1D1_Generalization/W1D1_Tutorial5.ipynb deleted file mode 100644 index 9a64735df..000000000 --- a/tutorials/W1D1_Generalization/W1D1_Tutorial5.ipynb +++ /dev/null @@ -1,980 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "12bb9e08-6996-4d6b-8b80-a7a26191c9d6", - "metadata": {}, - "outputs": [], - "source": [ - "# Imports\n", - "import scipy.io\n", - "import numpy as np\n", - "import torch\n", - "import torch.nn as nn\n", - "from torch.utils.data import TensorDataset, DataLoader\n", - "import torch.optim as optim\n", - "import os\n", - "import hashlib\n", - "import requests\n", - "from matplotlib import pyplot as plt\n", - "import tqdm as tqdm" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "85fea2ec-e1ee-4ebe-9dff-d3b253c3ba0b", - "metadata": {}, - "outputs": [], - "source": [ - "# Variables for file and download URL\n", - "fname = \"condsForSimJ2moMuscles.mat\" # The name of the file to be downloaded\n", - "url = \"https://osf.io/wak7e/download\" # URL from where the file will be downloaded\n", - "expected_md5 = \"257d16c4d92759d615bf5cac75dd9a1f\" # MD5 hash for verifying file integrity\n", - "\n", - "# Check if the file already exists\n", - "if not os.path.isfile(fname):\n", - " try:\n", - " # Attempt to download the file\n", - " r = requests.get(url) # Make a GET request to the specified URL\n", - " except requests.ConnectionError:\n", - " # Handle connection errors during the download\n", - " print(\"!!! Failed to download data !!!\")\n", - " else:\n", - " # No connection errors, proceed to check the response\n", - " if r.status_code != requests.codes.ok:\n", - " # Check if the HTTP response status code indicates a successful download\n", - " print(\"!!! Failed to download data !!!\")\n", - " elif hashlib.md5(r.content).hexdigest() != expected_md5:\n", - " # Verify the integrity of the downloaded file using MD5 checksum\n", - " print(\"!!! Data download appears corrupted !!!\")\n", - " else:\n", - " # If download is successful and data is not corrupted, save the file\n", - " with open(fname, \"wb\") as fid:\n", - " fid.write(r.content) # Write the downloaded content to a file" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "50c15d51-8e59-4305-a2bc-e270ac349085", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Memory usage before loading data: 316.7734375 MB\n", - "Go Envelope Tensor Trimmed Shape: torch.Size([216, 226, 1])\n", - "Plan Tensor Trimmed Shape: torch.Size([216, 226, 15])\n", - "Muscle Tensor Trimmed Shape: torch.Size([216, 226, 2])\n" - ] - }, - { - "data": { - "text/plain": [ - "0" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Before loading data, check memory usage\n", - "import psutil\n", - "print(f'Memory usage before loading data: {psutil.Process(os.getpid()).memory_info().rss / (1024 * 1024)} MB')\n", - "\n", - "# Load the .mat file\n", - "data = scipy.io.loadmat('condsForSimJ2moMuscles.mat')\n", - "\n", - "# Extract condsForSim struct\n", - "conds_for_sim = data['condsForSim']\n", - "\n", - "# Initialize lists to store data for all conditions\n", - "go_envelope_all = []\n", - "plan_all = []\n", - "muscle_all = []\n", - "\n", - "# Get the number of conditions (rows) and delay durations (columns)\n", - "num_conditions, num_delays = conds_for_sim.shape\n", - "\n", - "# Loop through each condition and extract data\n", - "for i in range(num_conditions): # 27 conditions\n", - " go_envelope_condition = []\n", - " plan_condition = []\n", - " muscle_condition = []\n", - "\n", - " for j in range(num_delays): # 8 delay durations\n", - " condition = conds_for_sim[i, j]\n", - "\n", - " go_envelope = condition['goEnvelope']\n", - " plan = condition['plan']\n", - " muscle = condition['muscle']\n", - "\n", - " # Select only muscles 5 and 6 \n", - " selected_muscle_data = muscle[:, [3, 4]] # which show the nicest multiphasic activity\n", - "\n", - " go_envelope_condition.append(go_envelope)\n", - " plan_condition.append(plan)\n", - " muscle_condition.append(selected_muscle_data)\n", - "\n", - " # Convert lists of NumPy arrays to single NumPy arrays before conversion to tensors\n", - " go_envelope_np = np.array(go_envelope_condition)\n", - " plan_np = np.array(plan_condition)\n", - " muscle_np = np.array(muscle_condition)\n", - "\n", - " # Convert the single NumPy arrays to PyTorch tensors\n", - " go_envelope_all.append(torch.tensor(go_envelope_np, dtype=torch.float32))\n", - " plan_all.append(torch.tensor(plan_np, dtype=torch.float32))\n", - " muscle_all.append(torch.tensor(muscle_np, dtype=torch.float32))\n", - "\n", - "# Stack data for all conditions\n", - "go_envelope_tensor = torch.stack(go_envelope_all)\n", - "plan_tensor = torch.stack(plan_all)\n", - "muscle_tensor = torch.stack(muscle_all)\n", - "\n", - "# Reshape to merge the first two dimensions\n", - "go_envelope_tensor = go_envelope_tensor.reshape(-1, *go_envelope_tensor.shape[2:])\n", - "plan_tensor = plan_tensor.reshape(-1, *plan_tensor.shape[2:])\n", - "muscle_tensor = muscle_tensor.reshape(-1, *muscle_tensor.shape[2:])\n", - "\n", - "# Remove the first 70 time steps\n", - "go_envelope_tensor = go_envelope_tensor[:, 70:, :]\n", - "plan_tensor = plan_tensor[:, 70:, :]\n", - "muscle_tensor = muscle_tensor[:, 70:, :]\n", - "\n", - "# Let's print the new shapes to confirm the change\n", - "print(f'Go Envelope Tensor Trimmed Shape: {go_envelope_tensor.shape}')\n", - "print(f'Plan Tensor Trimmed Shape: {plan_tensor.shape}')\n", - "print(f'Muscle Tensor Trimmed Shape: {muscle_tensor.shape}')\n", - "\n", - "# After tensors are created, we no longer need `data` and `conds_for_sim`\n", - "del data\n", - "del conds_for_sim\n", - "# After tensors are reshaped and you no longer need the original ones\n", - "del go_envelope_all\n", - "del plan_all\n", - "del muscle_all\n", - "del go_envelope_np\n", - "del plan_np\n", - "del muscle_np\n", - "\n", - "import gc\n", - "gc.collect()" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "417463ca-29c8-4229-baed-58dcf390747a", - "metadata": {}, - "outputs": [], - "source": [ - "# Normalization and Standardization\n", - "def normalize_and_standardize(tensor):\n", - "\n", - " # Standardize: shift to zero mean and unit variance\n", - " mean = tensor.mean()\n", - " std = tensor.std()\n", - " tensor = (tensor - mean) / std\n", - "\n", - " return tensor\n", - "\n", - "# Apply normalization and standardization to go_envelope_tensor and plan_tensor\n", - "normalized_go_envelope_tensor = normalize_and_standardize(go_envelope_tensor)\n", - "normalized_plan_tensor = normalize_and_standardize(plan_tensor)\n", - "normalized_muscle_tensor = muscle_tensor\n", - "\n", - "# Concatenate normalized tensors along the last dimension\n", - "X_train = torch.cat((normalized_go_envelope_tensor, normalized_plan_tensor), dim=2)\n", - "y_train = normalized_muscle_tensor\n", - "\n", - "batch_size = 256 # You can adjust this based on your data size and memory constraints\n", - "train_data = TensorDataset(X_train, y_train)\n", - "train_loader = DataLoader(train_data, batch_size=batch_size, shuffle=False)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "7e2b6a95-49a0-4f10-8f63-3b85a7f7d7be", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Epoch 1, Loss: 0.5519322156906128\n", - "Epoch 2, Loss: 0.4986596703529358\n", - "Epoch 3, Loss: 0.4689335823059082\n", - "Epoch 4, Loss: 0.4492972493171692\n", - "Epoch 5, Loss: 0.4316917061805725\n", - "Epoch 6, Loss: 0.41479480266571045\n", - "Epoch 7, Loss: 0.398833304643631\n", - "Epoch 8, Loss: 0.3844679594039917\n", - "Epoch 9, Loss: 0.3721160590648651\n", - "Epoch 10, Loss: 0.36075031757354736\n", - "Epoch 11, Loss: 0.3493914306163788\n", - "Epoch 12, Loss: 0.33835771679878235\n", - "Epoch 13, Loss: 0.32839053869247437\n", - "Epoch 14, Loss: 0.31947383284568787\n", - "Epoch 15, Loss: 0.3110644817352295\n", - "Epoch 16, Loss: 0.3029980957508087\n", - "Epoch 17, Loss: 0.29531052708625793\n", - "Epoch 18, Loss: 0.287977933883667\n", - "Epoch 19, Loss: 0.2811145782470703\n", - "Epoch 20, Loss: 0.2747448980808258\n", - "Epoch 21, Loss: 0.26856422424316406\n", - "Epoch 22, Loss: 0.2624956965446472\n", - "Epoch 23, Loss: 0.2566568851470947\n", - "Epoch 24, Loss: 0.25110575556755066\n", - "Epoch 25, Loss: 0.2458736151456833\n", - "Epoch 26, Loss: 0.24088245630264282\n", - "Epoch 27, Loss: 0.2360183298587799\n", - "Epoch 28, Loss: 0.2313256710767746\n", - "Epoch 29, Loss: 0.22685857117176056\n", - "Epoch 30, Loss: 0.2225888967514038\n", - "Epoch 31, Loss: 0.21851670742034912\n", - "Epoch 32, Loss: 0.2145949900150299\n", - "Epoch 33, Loss: 0.21078437566757202\n", - "Epoch 34, Loss: 0.20711404085159302\n", - "Epoch 35, Loss: 0.20359206199645996\n", - "Epoch 36, Loss: 0.20020133256912231\n", - "Epoch 37, Loss: 0.1969325840473175\n", - "Epoch 38, Loss: 0.19376400113105774\n", - "Epoch 39, Loss: 0.19071149826049805\n", - "Epoch 40, Loss: 0.18777306377887726\n", - "Epoch 41, Loss: 0.18495255708694458\n", - "Epoch 42, Loss: 0.18222197890281677\n", - "Epoch 43, Loss: 0.1795603632926941\n", - "Epoch 44, Loss: 0.17696455121040344\n", - "Epoch 45, Loss: 0.17446495592594147\n", - "Epoch 46, Loss: 0.1720551699399948\n", - "Epoch 47, Loss: 0.16972263157367706\n", - "Epoch 48, Loss: 0.1674545854330063\n", - "Epoch 49, Loss: 0.1652541160583496\n", - "Epoch 50, Loss: 0.1631237417459488\n", - "Epoch 51, Loss: 0.1610482931137085\n", - "Epoch 52, Loss: 0.15902777016162872\n", - "Epoch 53, Loss: 0.15706560015678406\n", - "Epoch 54, Loss: 0.15515753626823425\n", - "Epoch 55, Loss: 0.15330243110656738\n", - "Epoch 56, Loss: 0.151495099067688\n", - "Epoch 57, Loss: 0.1497366726398468\n", - "Epoch 58, Loss: 0.14803031086921692\n", - "Epoch 59, Loss: 0.14636950194835663\n", - "Epoch 60, Loss: 0.14475306868553162\n", - "Epoch 61, Loss: 0.14318086206912994\n", - "Epoch 62, Loss: 0.1416507065296173\n", - "Epoch 63, Loss: 0.14015871286392212\n", - "Epoch 64, Loss: 0.13870401680469513\n", - "Epoch 65, Loss: 0.13728773593902588\n", - "Epoch 66, Loss: 0.1359080821275711\n", - "Epoch 67, Loss: 0.13456253707408905\n", - "Epoch 68, Loss: 0.1332491934299469\n", - "Epoch 69, Loss: 0.13196663558483124\n", - "Epoch 70, Loss: 0.13071230053901672\n", - "Epoch 71, Loss: 0.12948517501354218\n", - "Epoch 72, Loss: 0.1282859593629837\n", - "Epoch 73, Loss: 0.12711575627326965\n", - "Epoch 74, Loss: 0.12597249448299408\n", - "Epoch 75, Loss: 0.12485451996326447\n", - "Epoch 76, Loss: 0.12376077473163605\n", - "Epoch 77, Loss: 0.12269100546836853\n", - "Epoch 78, Loss: 0.12164456397294998\n", - "Epoch 79, Loss: 0.12062013894319534\n", - "Epoch 80, Loss: 0.11961705982685089\n", - "Epoch 81, Loss: 0.118634894490242\n", - "Epoch 82, Loss: 0.1176738515496254\n", - "Epoch 83, Loss: 0.11673554033041\n", - "Epoch 84, Loss: 0.11582382023334503\n", - "Epoch 85, Loss: 0.11495845764875412\n", - "Epoch 86, Loss: 0.1142244040966034\n", - "Epoch 87, Loss: 0.11365008354187012\n", - "Epoch 88, Loss: 0.1128997877240181\n", - "Epoch 89, Loss: 0.11157360672950745\n", - "Epoch 90, Loss: 0.11110398918390274\n", - "Epoch 91, Loss: 0.11017798632383347\n", - "Epoch 92, Loss: 0.10941486060619354\n", - "Epoch 93, Loss: 0.10868389159440994\n", - "Epoch 94, Loss: 0.1078869104385376\n", - "Epoch 95, Loss: 0.10722575336694717\n", - "Epoch 96, Loss: 0.10645269602537155\n", - "Epoch 97, Loss: 0.1058158203959465\n", - "Epoch 98, Loss: 0.10506423562765121\n", - "Epoch 99, Loss: 0.1044677197933197\n", - "Epoch 100, Loss: 0.10373218357563019\n", - "Epoch 101, Loss: 0.1031772643327713\n", - "Epoch 102, Loss: 0.1024479940533638\n", - "Epoch 103, Loss: 0.10191866010427475\n", - "Epoch 104, Loss: 0.10122103989124298\n", - "Epoch 105, Loss: 0.10069246590137482\n", - "Epoch 106, Loss: 0.1000451147556305\n", - "Epoch 107, Loss: 0.09949776530265808\n", - "Epoch 108, Loss: 0.09891969710588455\n", - "Epoch 109, Loss: 0.09834467619657516\n", - "Epoch 110, Loss: 0.09782713651657104\n", - "Epoch 111, Loss: 0.0972403809428215\n", - "Epoch 112, Loss: 0.09674455970525742\n", - "Epoch 113, Loss: 0.0961964875459671\n", - "Epoch 114, Loss: 0.09567713737487793\n", - "Epoch 115, Loss: 0.09519167244434357\n", - "Epoch 116, Loss: 0.09466236084699631\n", - "Epoch 117, Loss: 0.09418143332004547\n", - "Epoch 118, Loss: 0.09371201694011688\n", - "Epoch 119, Loss: 0.09320862591266632\n", - "Epoch 120, Loss: 0.0927414745092392\n", - "Epoch 121, Loss: 0.09229478985071182\n", - "Epoch 122, Loss: 0.09182220697402954\n", - "Epoch 123, Loss: 0.09135950356721878\n", - "Epoch 124, Loss: 0.09092652797698975\n", - "Epoch 125, Loss: 0.09049703925848007\n", - "Epoch 126, Loss: 0.09005860984325409\n", - "Epoch 127, Loss: 0.08961967378854752\n", - "Epoch 128, Loss: 0.08919590711593628\n", - "Epoch 129, Loss: 0.08878778666257858\n", - "Epoch 130, Loss: 0.08839017897844315\n", - "Epoch 131, Loss: 0.08800011873245239\n", - "Epoch 132, Loss: 0.08761876076459885\n", - "Epoch 133, Loss: 0.08724765479564667\n", - "Epoch 134, Loss: 0.0868886411190033\n", - "Epoch 135, Loss: 0.08651196956634521\n", - "Epoch 136, Loss: 0.08610555529594421\n", - "Epoch 137, Loss: 0.08568298816680908\n", - "Epoch 138, Loss: 0.08531112223863602\n", - "Epoch 139, Loss: 0.0849844291806221\n", - "Epoch 140, Loss: 0.08464300632476807\n", - "Epoch 141, Loss: 0.0842752680182457\n", - "Epoch 142, Loss: 0.08389715850353241\n", - "Epoch 143, Loss: 0.08354433625936508\n", - "Epoch 144, Loss: 0.08321848511695862\n", - "Epoch 145, Loss: 0.08290661871433258\n", - "Epoch 146, Loss: 0.08260558545589447\n", - "Epoch 147, Loss: 0.08230576664209366\n", - "Epoch 148, Loss: 0.08200815320014954\n", - "Epoch 149, Loss: 0.08167603611946106\n", - "Epoch 150, Loss: 0.08131074905395508\n", - "Epoch 151, Loss: 0.08095855265855789\n", - "Epoch 152, Loss: 0.08067390322685242\n", - "Epoch 153, Loss: 0.08040428161621094\n", - "Epoch 154, Loss: 0.08009021729230881\n", - "Epoch 155, Loss: 0.07976528257131577\n", - "Epoch 156, Loss: 0.07945775985717773\n", - "Epoch 157, Loss: 0.07918529957532883\n", - "Epoch 158, Loss: 0.0789315477013588\n", - "Epoch 159, Loss: 0.07867088168859482\n", - "Epoch 160, Loss: 0.07842285931110382\n", - "Epoch 161, Loss: 0.07815377414226532\n", - "Epoch 162, Loss: 0.07786113023757935\n" - ] - } - ], - "source": [ - "# Define a custom Rectified Tanh activation function\n", - "def rectified_tanh(x):\n", - " return torch.where(x > 0, torch.tanh(x), 0) # was torch.where(x > 0, x, torch.tanh(x))\n", - "def grad_rectified_tanh(x):\n", - " return torch.where(x > 0, 1 - torch.tanh(x)**2, 0)\n", - "def grad_tanh(x):\n", - " return 1 - torch.tanh(x)**2\n", - " \n", - "class SimpleRNN(nn.Module):\n", - " def __init__(self, input_size, hidden_size, output_size, g, h, tau=50):\n", - " super(SimpleRNN, self).__init__()\n", - " self.hidden_size = hidden_size\n", - " self.tau = tau # Time constant\n", - " self.output_linear = nn.Linear(hidden_size, output_size) # New linear layer\n", - "\n", - " # Weight initialization\n", - " self.J = nn.Parameter(torch.randn(hidden_size, hidden_size) * (g / torch.sqrt(torch.tensor(hidden_size, dtype=torch.float))))\n", - " self.B = nn.Parameter(torch.randn(hidden_size, input_size) * (h / torch.sqrt(torch.tensor(input_size, dtype=torch.float)))) \n", - " self.bx = nn.Parameter(torch.zeros(hidden_size))\n", - "\n", - " # Nonlinearity\n", - " self.nonlinearity = rectified_tanh \n", - " \n", - " self.hidden_activations = [] \n", - " \n", - " def forward(self, x, hidden):\n", - " hidden_prev = hidden.clone()\n", - " timestep = self.tau / 10 # Timestep for Euler integration \n", - " # Update hidden state\n", - " firing_rate = self.nonlinearity(hidden) \n", - " hidden_update = torch.matmul(self.J, firing_rate.transpose(0, 1)) \n", - " input_update = torch.matmul(self.B, x.transpose(0, 1)) \n", - " new_hidden = hidden_update + input_update + self.bx.unsqueeze(1)\n", - " new_hidden = new_hidden.transpose(0, 1) \n", - " # Euler integration for continuous-time update\n", - " hidden = hidden + (timestep / self.tau) * (-hidden_prev + new_hidden) \n", - " # Output calculation\n", - " output = self.output_linear(firing_rate) \n", - " # Regularization terms\n", - " firing_rate_reg = hidden.pow(2).sum()\n", - " dynamic_reg = torch.linalg.norm(torch.matmul(self.J, grad_rectified_tanh(hidden.transpose(0, 1))), ord='fro', dim=(-2, -1)).sum()\n", - " \n", - " self.hidden_activations.append(hidden.clone())\n", - " \n", - " return output, hidden, firing_rate_reg, dynamic_reg\n", - "\n", - " def reset_activations(self):\n", - " self.hidden_activations = []\n", - " \n", - " def init_hidden(self, batch_size):\n", - " # Initialize hidden state with batch dimension\n", - " return torch.zeros(batch_size, self.hidden_size)\n", - "\n", - "def compute_l2_regularization(parameters, alpha):\n", - " l2_reg = sum(p.pow(2.0).sum() for p in parameters)\n", - " return alpha * l2_reg\n", - "\n", - "# Hyperparameters\n", - "input_size = 16\n", - "hidden_size = 150\n", - "output_size = 2 # Number of muscles\n", - "g = 1.5 # g value\n", - "h_val = 1.0 # h value\n", - "\n", - "# Hyperparameters for regularization\n", - "alpha = 1e-4 \n", - "beta = 0.03\n", - "gamma = 1e-4\n", - "\n", - "# Training Loop\n", - "num_epochs = 500\n", - "epoch_losses = [] \n", - "\n", - "# get available device\n", - "if torch.backends.mps.is_available():\n", - " device = torch.device('mps')\n", - "elif torch.cuda.is_available():\n", - " device = torch.device('cuda')\n", - "else:\n", - " device = torch.device('cpu')\n", - "\n", - "# Model instantiation\n", - "model = SimpleRNN(input_size, hidden_size, output_size, g, h_val)\n", - "model.to(device)\n", - "hidden_states_for_plot = []\n", - "# Loss Function and Optimizer\n", - "criterion = nn.MSELoss() # MSE Loss for regression tasks\n", - "optimizer = optim.Adam(model.parameters(), lr=0.001, weight_decay=0) ### WD=0. Note: Paper uses Hessian-Free optimizer\n", - "\n", - "for epoch in range(num_epochs):\n", - " running_loss = 0.0\n", - " for inputs, targets in train_loader:\n", - " inputs, targets = inputs.to(device), targets.to(device)\n", - " batch_size = inputs.size(0)\n", - " h = model.init_hidden(batch_size).to(device) # Initialize hidden state with the current batch size\n", - " optimizer.zero_grad()\n", - "\n", - " total_firing_rate_reg = 0\n", - " total_dynamic_reg = 0\n", - "\n", - " for t in range(inputs.shape[1]): # Iterate over time steps\n", - " output, h, firing_rate_reg, dynamic_reg = model(inputs[:, t, :], h)\n", - " hidden_states_for_plot.append(h.detach().cpu().numpy())\n", - " total_firing_rate_reg += firing_rate_reg\n", - " total_dynamic_reg += dynamic_reg\n", - " # Clear memory of intermediate tensors\n", - " del firing_rate_reg, dynamic_reg\n", - " torch.cuda.empty_cache()\n", - " gc.collect()\n", - "\n", - " # Compute loss using the last output and include regularization terms\n", - " loss = criterion(output, targets[:, -1, :])\n", - " l2_reg = compute_l2_regularization(model.parameters(), alpha)\n", - " rfr_reg = beta * total_firing_rate_reg / inputs.shape[1] / hidden_size /num_conditions # Average over time steps\n", - " rj_reg = gamma * total_firing_rate_reg / inputs.shape[1] /num_conditions # Average over time steps\n", - " \n", - " total_loss = loss + l2_reg + rfr_reg + rj_reg\n", - "\n", - " total_loss.backward()\n", - " torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1)\n", - " optimizer.step()\n", - " \n", - " running_loss += total_loss.item()\n", - "\n", - " # Clear memory at the end of each batch\n", - " del inputs, targets, h\n", - "\n", - " avg_loss = running_loss / float(len(train_loader))\n", - " epoch_losses.append(avg_loss)\n", - " print(f'Epoch {epoch + 1}, Loss: {avg_loss}')\n", - "\n", - "\n", - " torch.cuda.empty_cache()\n", - " gc.collect()\n", - "\n", - "print('Finished Training')\n", - "\n", - "# Clear cache after training\n", - "if device.type == 'cuda':\n", - " torch.cuda.empty_cache()\n", - " \n", - "# Monitor memory usage after training\n", - "print(f'Memory usage after training: {psutil.Process(os.getpid()).memory_info().rss / (1024 * 1024)} MB') \n", - "\n", - "# Plotting\n", - "plt.figure(figsize=(10, 6))\n", - "plt.plot(range(1, num_epochs + 1), epoch_losses, label='Training Loss')\n", - "plt.xlabel('Epoch')\n", - "plt.ylabel('Loss')\n", - "plt.title('Training Loss Over Epochs')\n", - "plt.legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "21dd9a5b-0e80-4464-aa8e-9ec54d225646", - "metadata": {}, - "outputs": [], - "source": [ - "import torch\n", - "import torch.nn as nn\n", - "import torch.optim as optim\n", - "\n", - "# Custom activation function (remains unchanged)\n", - "def rectified_tanh(x):\n", - " return torch.where(x > 0, torch.tanh(x), 0)\n", - "\n", - "# ComplicatedRNN class\n", - "class ComplicatedRNN(nn.Module):\n", - " def __init__(self, input_size, hidden_size, output_size, g, h, tau=50):\n", - " super(ComplicatedRNN, self).__init__()\n", - " self.hidden_size = hidden_size\n", - " self.tau = tau\n", - " self.output_linear = nn.Linear(hidden_size, output_size)\n", - "\n", - " # Weight initialization (unchanged)\n", - " self.J = nn.Parameter(torch.randn(hidden_size, hidden_size) * (g / torch.sqrt(torch.tensor(hidden_size, dtype=torch.float))))\n", - " self.B = nn.Parameter(torch.randn(hidden_size, input_size) * (h / torch.sqrt(torch.tensor(input_size, dtype=torch.float)))) \n", - " self.bx = nn.Parameter(torch.zeros(hidden_size))\n", - "\n", - " # Nonlinearity (unchanged)\n", - " self.nonlinearity = rectified_tanh \n", - " \n", - " self.hidden_activations = [] \n", - "\n", - " def forward(self, x, hidden):\n", - " # Forward pass logic (same as SimpleRNN but without regularization terms)\n", - " hidden_prev = hidden.clone()\n", - " timestep = self.tau / 10\n", - "\n", - " firing_rate = self.nonlinearity(hidden)\n", - " \n", - " hidden_update = torch.matmul(self.J, firing_rate.transpose(0, 1))\n", - " input_update = torch.matmul(self.B, x.transpose(0, 1))\n", - " \n", - " new_hidden = hidden_update + input_update + self.bx.unsqueeze(1)\n", - " new_hidden = new_hidden.transpose(0, 1)\n", - " \n", - " hidden = hidden + (timestep / self.tau) * (-hidden_prev + new_hidden)\n", - " output = self.output_linear(firing_rate)\n", - " \n", - " self.hidden_activations.append(hidden.clone())\n", - "\n", - " return output, hidden\n", - " \n", - " def reset_activations(self):\n", - " self.hidden_activations = []\n", - " \n", - " def init_hidden(self, batch_size):\n", - " return torch.zeros(batch_size, self.hidden_size)\n", - "\n", - "# Training loop\n", - "# Hyperparameters \n", - "input_size = 16\n", - "hidden_size = 150\n", - "output_size = 2\n", - "g = 4\n", - "h_val = 1.0\n", - "num_epochs = 500\n", - "epoch_losses = []\n", - "\n", - "# Device setup and model instantiation \n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", - "complicated_model = ComplicatedRNN(input_size, hidden_size, output_size, g, h_val)\n", - "complicated_model.to(device)\n", - "hidden_states_for_plot_cm = []\n", - "\n", - "# Loss function and optimizer (no weight decay)\n", - "criterion = nn.MSELoss()\n", - "optimizer = optim.Adam(complicated_model.parameters(), lr=0.001)\n", - "\n", - "# Training loop (updated to remove regularization terms)\n", - "for epoch in range(num_epochs):\n", - " running_loss = 0.0\n", - " for inputs, targets in train_loader:\n", - " inputs, targets = inputs.to(device), targets.to(device)\n", - " batch_size = inputs.size(0)\n", - " h = complicated_model.init_hidden(batch_size).to(device)\n", - " optimizer.zero_grad()\n", - "\n", - " for t in range(inputs.shape[1]):\n", - " output, h = complicated_model(inputs[:, t, :], h)\n", - " hidden_states_for_plot_cm.append(h.detach().cpu().numpy())\n", - "\n", - " loss = criterion(output, targets[:, -1, :])\n", - " loss.backward()\n", - " torch.nn.utils.clip_grad_norm_(complicated_model.parameters(), max_norm=1)\n", - " optimizer.step()\n", - " \n", - " running_loss += loss.item()\n", - "\n", - " avg_loss = running_loss / len(train_loader)\n", - " epoch_losses.append(avg_loss)\n", - " print(f'Epoch {epoch + 1}, Loss: {avg_loss}')\n", - "\n", - "print('Finished Training')\n", - "\n", - "# Plotting\n", - "plt.figure(figsize=(10, 6))\n", - "plt.plot(range(1, num_epochs + 1), epoch_losses, label='Training Loss')\n", - "plt.xlabel('Epoch')\n", - "plt.ylabel('Loss')\n", - "plt.title('Training Loss Over Epochs')\n", - "plt.legend()\n", - "plt.show()\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "52cd598c-a42e-4219-aa9b-5b7e54710749", - "metadata": {}, - "outputs": [], - "source": [ - "import matplotlib.pyplot as plt\n", - "import torch\n", - "\n", - "def plot_psth(data, title, bin_size=10):\n", - " \"\"\"\n", - " Plot Peri-Stimulus Time Histogram (PSTH) for given data.\n", - " :param data: a tensor containing the neural data\n", - " :param title: a string for the plot title\n", - " :param bin_size: size of time bins for averaging\n", - " \"\"\"\n", - " # Averaging neural activity across trials for each time bin\n", - " mean_data = data.mean(dim=0) # Mean across trials\n", - " n_bins = mean_data.shape[0] // bin_size\n", - "\n", - " # Prepare the data for plotting\n", - " binned_data = mean_data.unfold(0, bin_size, bin_size).mean(dim=2)\n", - "\n", - " # Plot\n", - " plt.figure(figsize=(10, 6))\n", - " for i in range(data.shape[2]): # Iterate over each channel/neuron\n", - " plt.plot(binned_data[:, i], label=f'Channel {i+1}')\n", - " plt.xlabel('Time (bins)')\n", - " plt.ylabel('Average Neural Activity')\n", - " plt.title(title)\n", - " plt.legend()\n", - " plt.show()\n", - "\n", - "# Example Usage\n", - "plot_psth(normalized_muscle_tensor, \"PSTH for Arm Movement\")\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "fa5362de-9acf-4380-af3b-68acded8eb1f", - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "\n", - "# Convert list of numpy arrays to a single numpy array\n", - "hidden_states = np.array(hidden_states_for_plot)\n", - "\n", - "# Calculate the mean across all batches for each time step\n", - "# Assuming hidden_states.shape is [num_samples, num_time_steps, hidden_size]\n", - "mean_activations = np.mean(hidden_states, axis=0)\n", - "\n", - "# Plot the PSTHs for the first few neurons\n", - "neurons_to_plot = 5 # Adjust this number as needed\n", - "time_steps = mean_activations.shape[0]\n", - "plt.figure(figsize=(12, 8))\n", - "\n", - "for i in range(min(neurons_to_plot, hidden_states.shape[2])):\n", - " plt.plot(range(time_steps), mean_activations[:, i], label=f'Neuron {i+1}')\n", - "\n", - "plt.xlabel('Time Steps')\n", - "plt.ylabel('Average Activation')\n", - "plt.title('PSTHs of Hidden Units in SimpleRNN')\n", - "plt.legend()\n", - "plt.show()\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "825b011e-0fa3-4e5f-a423-0074f069f30c", - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "\n", - "# Convert list of numpy arrays to a single numpy array\n", - "hidden_states_cm = np.array(hidden_states_for_plot_cm)\n", - "\n", - "# Calculate the mean across all batches for each time step\n", - "# Assuming hidden_states.shape is [num_samples, num_time_steps, hidden_size]\n", - "mean_activations_cm = np.mean(hidden_states_cm, axis=0)\n", - "\n", - "# Plot the PSTHs for the first few neurons\n", - "neurons_to_plot = 5 # Adjust this number as needed\n", - "time_steps_cm = mean_activations_cm.shape[0]\n", - "plt.figure(figsize=(12, 8))\n", - "\n", - "for i in range(min(neurons_to_plot, hidden_states_cm.shape[2])):\n", - " plt.plot(range(time_steps), mean_activations_cm[:, i], label=f'Neuron {i+1}')\n", - "\n", - "plt.xlabel('Time Steps')\n", - "plt.ylabel('Average Activation')\n", - "plt.title('PSTHs of Hidden Units in ComplicatedRNN')\n", - "plt.legend()\n", - "plt.show()\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "bf6d4256-8aa3-423e-9e9a-24d3cb675808", - "metadata": {}, - "outputs": [], - "source": [ - "import torch\n", - "import numpy as np\n", - "\n", - "def perturb_inputs(model, inputs, perturbation_strength):\n", - " # Perturb the inputs by adding random noise scaled by the perturbation strength\n", - " noise = torch.randn_like(inputs) * perturbation_strength\n", - " perturbed_inputs = inputs + noise\n", - " return perturbed_inputs\n", - "\n", - "def test_perturbed_inputs(model, perturbation_strengths, test_loader, criterion, device):\n", - " model.eval() # Set the model to evaluation mode\n", - " perturbation_errors = []\n", - "\n", - " for strength in perturbation_strengths:\n", - " batch_errors = [] # Store errors for each batch in the test_loader\n", - " \n", - " for inputs, targets in test_loader:\n", - " inputs = inputs.to(device)\n", - " targets = targets.to(device)\n", - " batch_size = inputs.size(0)\n", - " h = model.init_hidden(batch_size).to(device) # Initialize hidden state\n", - " \n", - " perturbed_inputs = perturb_inputs(model, inputs, strength) # Perturb inputs here\n", - "\n", - " for t in range(inputs.shape[1]): # Iterate over time steps\n", - " model_output = model(perturbed_inputs[:, t, :], h)\n", - " if len(model_output) == 4: # If the model returns 4 outputs, unpack all (simple model)\n", - " output, h, _, _ = model_output\n", - " else: # If the model returns 2 outputs, unpack accordingly (complicated model)\n", - " output, h = model_output\n", - " \n", - " # Compute loss for the entire sequence (last output)\n", - " loss = criterion(output, targets[:, -1, :]).item()\n", - " batch_errors.append(loss) # Append the loss of this batch\n", - " \n", - " mean_error = np.mean(batch_errors) # Calculate mean error for this perturbation strength\n", - " perturbation_errors.append(mean_error)\n", - " print(f'Perturbation strength: {strength}, Mean Error: {mean_error}')\n", - " \n", - " return perturbation_errors\n", - "\n", - "perturbation_strengths = [0.0001, 0.001, 0.01, 0.1, 1]\n", - "simple_model_errors = test_perturbed_inputs(model, perturbation_strengths, train_loader, criterion, device)\n", - "complex_model_errors = test_perturbed_inputs(complicated_model, perturbation_strengths, train_loader, criterion, device)\n", - "\n", - "import matplotlib.pyplot as plt\n", - "\n", - "# Convert errors to percentages \n", - "simple_model_errors_percent = [error * 100 for error in simple_model_errors]\n", - "complex_model_errors_percent = [error * 100 for error in complex_model_errors]\n", - "\n", - "# Adjust the width of the bars here\n", - "bar_width = 0.1 # Smaller values make narrower bars\n", - "\n", - "import numpy as np # Import numpy for array manipulation\n", - "\n", - "# Define your perturbation strengths\n", - "perturbation_strengths = [0.0001, 0.001, 0.01, 0.1, 1]\n", - "bar_width = 0.2 # Adjust the bar width as needed\n", - "\n", - "# Create an array of indices for the x-axis ticks\n", - "x_indices = np.arange(len(perturbation_strengths))\n", - "\n", - "# Plotting\n", - "plt.figure(figsize=(12, 6))\n", - "\n", - "# Subplot for the simple model\n", - "plt.subplot(1, 2, 1)\n", - "plt.bar(x_indices, simple_model_errors_percent, width=bar_width, color='blue', label='Simple RNN')\n", - "plt.xlabel('Perturbation Strength')\n", - "plt.ylabel('Mean Error (%)')\n", - "plt.title('Simple Model Robustness')\n", - "plt.legend()\n", - "\n", - "# Subplot for the complex model\n", - "plt.subplot(1, 2, 2)\n", - "plt.bar(x_indices, complex_model_errors_percent, width=bar_width, color='red', label='Complicated RNN')\n", - "plt.xlabel('Perturbation Strength')\n", - "plt.ylabel('Mean Error (%)')\n", - "plt.title('Complex Model Robustness')\n", - "plt.legend()\n", - "\n", - "# Set custom tick positions and labels on the x-axis\n", - "plt.xticks(x_indices, perturbation_strengths)\n", - "\n", - "# Display the plots\n", - "plt.tight_layout()\n", - "plt.show()\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "41ae5f60-f9a1-4ead-adcd-42493d32ffdf", - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import torch\n", - "import matplotlib.pyplot as plt\n", - "from torch import nn, optim\n", - "import torch.backends.mps\n", - "from torch.utils.data import DataLoader\n", - "\n", - "# Assuming train_loader is defined elsewhere and is a DataLoader instance\n", - "# Assuming the models are instances of SimpleRNN or similar\n", - "\n", - "def perturb_recurrent_weights(model, perturbation_strength):\n", - " # Perturb the recurrent weight matrix J by adding Gaussian noise\n", - " with torch.no_grad():\n", - " noise = torch.randn_like(model.J) * perturbation_strength\n", - " perturbed_weights = model.J + noise\n", - " return perturbed_weights\n", - "\n", - "def test_perturbed_structure(model, perturbation_strengths, test_loader, criterion, device):\n", - " model.eval() # Set the model to evaluation mode\n", - " perturbation_errors = []\n", - " original_weights = model.J.data.clone() # Save the original weights\n", - "\n", - " for strength in perturbation_strengths:\n", - " batch_errors = [] # Store errors for each batch in the test_loader\n", - " # Perturb the recurrent weights of the model\n", - " perturbed_weights = perturb_recurrent_weights(model, strength)\n", - " model.J.data = perturbed_weights.data\n", - "\n", - " for inputs, targets in test_loader:\n", - " inputs = inputs.to(device)\n", - " targets = targets.to(device)\n", - " batch_size = inputs.size(0)\n", - " h = model.init_hidden(batch_size).to(device) # Initialize hidden state\n", - " \n", - " for t in range(inputs.shape[1]): # Iterate over time steps\n", - " model_output = model(inputs[:, t, :], h)\n", - " if len(model_output) == 4: # If the model returns 4 outputs, unpack all (simple model)\n", - " output, h, _, _ = model_output\n", - " else: # If the model returns 2 outputs, unpack accordingly (complicated model)\n", - " output, h = model_output\n", - " \n", - " # Compute loss for the entire sequence (last output)\n", - " loss = criterion(output, targets[:, -1, :]).item()\n", - " batch_errors.append(loss) # Append the loss of this batch\n", - " \n", - " # Restore the original weights before the next iteration\n", - " model.J.data = original_weights.data\n", - " \n", - " mean_error = np.mean(batch_errors) # Calculate mean error for this perturbation strength\n", - " perturbation_errors.append(mean_error)\n", - " print(f'Perturbation strength: {strength}, Mean Error: {mean_error}')\n", - " \n", - " return perturbation_errors\n", - "\n", - "# Define your perturbation strengths\n", - "perturbation_strengths = [0.0001, 0.001, 0.01, 0.1, 1]\n", - "\n", - "# Get errors for simple and complex models\n", - "simple_model_structural_errors = test_perturbed_structure(model, perturbation_strengths, train_loader, criterion, device)\n", - "complex_model_structural_errors = test_perturbed_structure(complicated_model, perturbation_strengths, train_loader, criterion, device)\n", - "\n", - "# Convert errors to percentages \n", - "simple_model_errors_percent = [error * 100 for error in simple_model_structural_errors]\n", - "complex_model_errors_percent = [error * 100 for error in complex_model_structural_errors]\n", - "\n", - "# Define your perturbation strengths\n", - "perturbation_strengths = [0.0001, 0.001, 0.01, 0.1, 1]\n", - "\n", - "# Create an array of indices for the x-axis ticks\n", - "x_indices = np.arange(len(perturbation_strengths))\n", - "\n", - "# Plotting\n", - "plt.figure(figsize=(12, 6))\n", - "\n", - "# For the simple model\n", - "plt.subplot(1, 2, 1)\n", - "plt.bar(x_indices, simple_model_errors_percent, color='blue', label='Simple RNN')\n", - "plt.xlabel('Perturbation Strength (log scale)')\n", - "plt.ylabel('Mean Error (%)')\n", - "plt.title('Simple Model Robustness')\n", - "plt.legend()\n", - "\n", - "# For the complex model\n", - "plt.subplot(1, 2, 2)\n", - "plt.bar(x_indices, complex_model_errors_percent, color='red', label='Complicated RNN')\n", - "plt.xlabel('Perturbation Strength (log scale)')\n", - "plt.ylabel('Mean Error (%)')\n", - "plt.title('Complex Model Robustness')\n", - "plt.legend()\n", - "\n", - "# Set custom tick positions and labels on the x-axis\n", - "plt.xticks(x_indices, perturbation_strengths)\n", - "\n", - "# Display the plots\n", - "plt.tight_layout()\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "257161c9-9155-4dfd-b089-b12ac2725dde", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "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.10.12" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -}