From 40b1cb360b598bd7d232c658848196cb1fb43277 Mon Sep 17 00:00:00 2001 From: Zach Date: Mon, 23 Nov 2020 04:23:21 +0000 Subject: [PATCH 01/16] Accomodate batch size of 1 --- PyTorch/SpeechSynthesis/Tacotron2/tacotron2/model.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PyTorch/SpeechSynthesis/Tacotron2/tacotron2/model.py b/PyTorch/SpeechSynthesis/Tacotron2/tacotron2/model.py index 4976b54c3..ff0869567 100644 --- a/PyTorch/SpeechSynthesis/Tacotron2/tacotron2/model.py +++ b/PyTorch/SpeechSynthesis/Tacotron2/tacotron2/model.py @@ -501,7 +501,7 @@ def forward(self, memory, decoder_inputs, memory_lengths): mask) mel_outputs += [mel_output.squeeze(1)] - gate_outputs += [gate_output.squeeze()] + gate_outputs += [gate_output.squeeze(1)] alignments += [attention_weights] mel_outputs, gate_outputs, alignments = self.parse_decoder_outputs( From 32e30c6c216b7f4e6e85175e6fb3722b36269c32 Mon Sep 17 00:00:00 2001 From: Ubuntu Date: Sat, 13 Feb 2021 16:24:07 +0000 Subject: [PATCH 02/16] add sampling notebook --- .../SpeechSynthesis/Tacotron2/Samples.ipynb | 583 ++++++++++++++++++ 1 file changed, 583 insertions(+) create mode 100644 PyTorch/SpeechSynthesis/Tacotron2/Samples.ipynb diff --git a/PyTorch/SpeechSynthesis/Tacotron2/Samples.ipynb b/PyTorch/SpeechSynthesis/Tacotron2/Samples.ipynb new file mode 100644 index 000000000..6f1e499e9 --- /dev/null +++ b/PyTorch/SpeechSynthesis/Tacotron2/Samples.ipynb @@ -0,0 +1,583 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import hifi_gan\n", + "import torch" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import g2p_en" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "g2p = g2p_en.G2p()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "import re\n", + "\n", + "def to_arpabet(g2p, text):\n", + " \"\"\"Convert a sentence in english to arpabet.\"\"\"\n", + " g2p_out = g2p(text)\n", + " current = 0\n", + " current_tokens = []\n", + " current_token_is_punc = False\n", + " output = []\n", + " while True:\n", + " if current >= len(g2p_out) or g2p_out[current] == \" \":\n", + " if current_token_is_punc:\n", + " output.append(\"\".join(current_tokens))\n", + " else:\n", + " output.append(\"{%s}\" % (\" \".join(current_tokens)))\n", + " current_tokens = []\n", + " if current >= len(g2p_out):\n", + " break\n", + " else:\n", + " if len(current_tokens) == 0:\n", + " current_token_is_punc = (\n", + " re.match(r\"[,'\\-!\\.?]+\", g2p_out[current]) is not None\n", + " )\n", + " current_tokens.append(g2p_out[current])\n", + " current += 1\n", + "\n", + " return \" \".join(output)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import json\n", + "import hifi_gan\n", + "from hifi_gan.env import AttrDict\n", + "from hifi_gan.inference_e2e import load_checkpoint\n", + "from hifi_gan.meldataset import MAX_WAV_VALUE\n", + "from hifi_gan.models import Generator\n", + "\n", + "def load_hifi_gan(path, device=\"cpu\"):\n", + " dev = torch.device(device)\n", + " with open(os.path.join(path, \"config.json\"), \"r\") as f:\n", + " config = AttrDict(json.load(f))\n", + " generator = Generator(config).to(dev)\n", + " for file in os.listdir(path):\n", + " if file.startswith(\"g_\"):\n", + " gen_filename = file\n", + " state_dict_g = load_checkpoint(os.path.join(path, gen_filename), dev)\n", + " print(state_dict_g.keys())\n", + " generator.load_state_dict(state_dict_g['generator'])\n", + " generator.eval()\n", + " generator.remove_weight_norm()\n", + " return generator" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading '/home/ubuntu/UNIVERSAL_V1/g_02500000'\n", + "Complete.\n", + "dict_keys(['generator'])\n", + "Removing weight norm...\n" + ] + } + ], + "source": [ + "gen = load_hifi_gan(\"/home/ubuntu/UNIVERSAL_V1/\", device=\"cuda\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Using cache found in /home/ubuntu/.cache/torch/hub/nvidia_DeepLearningExamples_torchhub\n" + ] + } + ], + "source": [ + "model = torch.hub.load(\n", + " \"nvidia/DeepLearningExamples:torchhub\", \n", + " \"nvidia_tacotron2\", \n", + " pretrained=False,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "michael rosen\n", + "checkpoint_Tacotron2_1000.pt checkpoint_Tacotron2_1920.pt\n", + "checkpoint_Tacotron2_1010.pt checkpoint_Tacotron2_1940.pt\n", + "checkpoint_Tacotron2_1020.pt checkpoint_Tacotron2_1960.pt\n", + "checkpoint_Tacotron2_1030.pt checkpoint_Tacotron2_1980.pt\n", + "checkpoint_Tacotron2_1040.pt checkpoint_Tacotron2_2000.pt\n", + "checkpoint_Tacotron2_1050.pt checkpoint_Tacotron2_360.pt\n", + "checkpoint_Tacotron2_1060.pt checkpoint_Tacotron2_370.pt\n", + "checkpoint_Tacotron2_1070.pt checkpoint_Tacotron2_380.pt\n", + "checkpoint_Tacotron2_1080.pt checkpoint_Tacotron2_390.pt\n", + "checkpoint_Tacotron2_1090.pt checkpoint_Tacotron2_400.pt\n", + "checkpoint_Tacotron2_1100.pt checkpoint_Tacotron2_410.pt\n", + "checkpoint_Tacotron2_1110.pt checkpoint_Tacotron2_420.pt\n", + "checkpoint_Tacotron2_1120.pt checkpoint_Tacotron2_430.pt\n", + "checkpoint_Tacotron2_1130.pt checkpoint_Tacotron2_440.pt\n", + "checkpoint_Tacotron2_1140.pt checkpoint_Tacotron2_450.pt\n", + "checkpoint_Tacotron2_1150.pt checkpoint_Tacotron2_460.pt\n", + "checkpoint_Tacotron2_1160.pt checkpoint_Tacotron2_470.pt\n", + "checkpoint_Tacotron2_1170.pt checkpoint_Tacotron2_480.pt\n", + "checkpoint_Tacotron2_1180.pt checkpoint_Tacotron2_490.pt\n", + "checkpoint_Tacotron2_1190.pt checkpoint_Tacotron2_500.pt\n", + "checkpoint_Tacotron2_1200.pt checkpoint_Tacotron2_510.pt\n", + "checkpoint_Tacotron2_1210.pt checkpoint_Tacotron2_520.pt\n", + "checkpoint_Tacotron2_1220.pt checkpoint_Tacotron2_530.pt\n", + "checkpoint_Tacotron2_1230.pt checkpoint_Tacotron2_540.pt\n", + "checkpoint_Tacotron2_1240.pt checkpoint_Tacotron2_550.pt\n", + "checkpoint_Tacotron2_1250.pt checkpoint_Tacotron2_560.pt\n", + "checkpoint_Tacotron2_1260.pt checkpoint_Tacotron2_570.pt\n", + "checkpoint_Tacotron2_1270.pt checkpoint_Tacotron2_580.pt\n", + "checkpoint_Tacotron2_1280.pt checkpoint_Tacotron2_590.pt\n", + "checkpoint_Tacotron2_1290.pt checkpoint_Tacotron2_600.pt\n", + "checkpoint_Tacotron2_1300.pt checkpoint_Tacotron2_610.pt\n", + "checkpoint_Tacotron2_1310.pt checkpoint_Tacotron2_620.pt\n", + "checkpoint_Tacotron2_1320.pt checkpoint_Tacotron2_630.pt\n", + "checkpoint_Tacotron2_1330.pt checkpoint_Tacotron2_640.pt\n", + "checkpoint_Tacotron2_1340.pt checkpoint_Tacotron2_650.pt\n", + "checkpoint_Tacotron2_1350.pt checkpoint_Tacotron2_660.pt\n", + "checkpoint_Tacotron2_1360.pt checkpoint_Tacotron2_670.pt\n", + "checkpoint_Tacotron2_1370.pt checkpoint_Tacotron2_680.pt\n", + "checkpoint_Tacotron2_1380.pt checkpoint_Tacotron2_690.pt\n", + "checkpoint_Tacotron2_1390.pt checkpoint_Tacotron2_700.pt\n", + "checkpoint_Tacotron2_1400.pt checkpoint_Tacotron2_710.pt\n", + "checkpoint_Tacotron2_1410.pt checkpoint_Tacotron2_720.pt\n", + "checkpoint_Tacotron2_1420.pt checkpoint_Tacotron2_730.pt\n", + "checkpoint_Tacotron2_1430.pt checkpoint_Tacotron2_740.pt\n", + "checkpoint_Tacotron2_1440.pt checkpoint_Tacotron2_750.pt\n", + "checkpoint_Tacotron2_1450.pt checkpoint_Tacotron2_760.pt\n", + "checkpoint_Tacotron2_1460.pt checkpoint_Tacotron2_770.pt\n", + "checkpoint_Tacotron2_1470.pt checkpoint_Tacotron2_780.pt\n", + "checkpoint_Tacotron2_1480.pt checkpoint_Tacotron2_790.pt\n", + "checkpoint_Tacotron2_1490.pt checkpoint_Tacotron2_800.pt\n", + "checkpoint_Tacotron2_1500.pt checkpoint_Tacotron2_810.pt\n", + "checkpoint_Tacotron2_1520.pt checkpoint_Tacotron2_820.pt\n", + "checkpoint_Tacotron2_1540.pt checkpoint_Tacotron2_830.pt\n", + "checkpoint_Tacotron2_1560.pt checkpoint_Tacotron2_840.pt\n", + "checkpoint_Tacotron2_1580.pt checkpoint_Tacotron2_850.pt\n", + "checkpoint_Tacotron2_1600.pt checkpoint_Tacotron2_860.pt\n", + "checkpoint_Tacotron2_1620.pt checkpoint_Tacotron2_870.pt\n", + "checkpoint_Tacotron2_1640.pt checkpoint_Tacotron2_880.pt\n", + "checkpoint_Tacotron2_1660.pt checkpoint_Tacotron2_890.pt\n", + "checkpoint_Tacotron2_1680.pt checkpoint_Tacotron2_900.pt\n", + "checkpoint_Tacotron2_1700.pt checkpoint_Tacotron2_910.pt\n", + "checkpoint_Tacotron2_1720.pt checkpoint_Tacotron2_920.pt\n", + "checkpoint_Tacotron2_1740.pt checkpoint_Tacotron2_930.pt\n", + "checkpoint_Tacotron2_1760.pt checkpoint_Tacotron2_940.pt\n", + "checkpoint_Tacotron2_1780.pt checkpoint_Tacotron2_950.pt\n", + "checkpoint_Tacotron2_1800.pt checkpoint_Tacotron2_960.pt\n", + "checkpoint_Tacotron2_1820.pt checkpoint_Tacotron2_970.pt\n", + "checkpoint_Tacotron2_1840.pt checkpoint_Tacotron2_980.pt\n", + "checkpoint_Tacotron2_1860.pt checkpoint_Tacotron2_990.pt\n", + "checkpoint_Tacotron2_1880.pt checkpoint_Tacotron2_last.pt\n", + "checkpoint_Tacotron2_1900.pt nvlog.json\n", + "trebek\n", + "checkpoint_Tacotron2_350.pt checkpoint_Tacotron2_500.pt nvlog.json\n", + "checkpoint_Tacotron2_400.pt checkpoint_Tacotron2_550.pt\n", + "checkpoint_Tacotron2_450.pt checkpoint_Tacotron2_last.pt\n", + "lj\n", + "checkpoint_Tacotron2_0.pt checkpoint_Tacotron2_450.pt\n", + "checkpoint_Tacotron2_100.pt checkpoint_Tacotron2_50.pt\n", + "checkpoint_Tacotron2_150.pt checkpoint_Tacotron2_500.pt\n", + "checkpoint_Tacotron2_200.pt checkpoint_Tacotron2_550.pt\n", + "checkpoint_Tacotron2_250.pt checkpoint_Tacotron2_600.pt\n", + "checkpoint_Tacotron2_300.pt checkpoint_Tacotron2_650.pt\n", + "checkpoint_Tacotron2_350.pt checkpoint_Tacotron2_last.pt\n", + "checkpoint_Tacotron2_400.pt nvlog.json\n" + ] + } + ], + "source": [ + "print(\"michael rosen\")\n", + "!ls output_michaelrosen/\n", + "print(\"trebek\")\n", + "!ls output_trebek/\n", + "print(\"lj\")\n", + "!ls output" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "checkpoint = torch.load(\"output_michaelrosen/checkpoint_Tacotron2_last.pt\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.load_state_dict(checkpoint[\"state_dict\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{AY1 D} {JH AH1 S T} {L AY1 K} {T UW1} {IH2 N T ER0 JH EH1 K T} {F AO1 R} {AH0} {M OW1 M AH0 N T} . {W AH1 T} {Y UH1 R} {R IH0 F ER1 IH0 NG} {T UW1} {AE1 Z} {L IH1 N AH0 K S} , {IH1 Z} {IH0 N} {F AE1 K T} , {W IH1 N D OW0 Z} {S AH1 B S IH2 S T AH0 M} {F AO1 R} {L IH1 N AH0 K S} , {AO1 R} {AE1 Z} {AY1 V} {R IY1 S AH0 N T L IY0} {T EY1 K AH0 N} {T UW1} {K AO1 L IH0 NG} {IH1 T} , {D AH1 B AH0 L Y UW0} {EH1 S} {EH1 L} .\n" + ] + } + ], + "source": [ + "arpabet = to_arpabet(\n", + " g2p,\n", + " # \"Never gonna give you up. Never gonna let you down. Never gonna run around and desert me.\"\n", + " # \"What the fuck did you just fucking say about me, you little bitch?\"\n", + " # \"Loads to eat, I had cod and chips, the cod was huge and there were hundreds of chips.\"\n", + " #\"I'm infinite. You heard of hell? Well I was sent from it.\"\n", + " \"I'd just like to interject for a moment. What you're referring to as Linux, is in fact, Windows Subsystem for Linux, or as I've recently taken to calling it, W S L.\"\n", + ")\n", + "print(arpabet)" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [], + "source": [ + "from tacotron2.text import text_to_sequence\n", + "import numpy as np\n", + "model = model.cuda()" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "seq = np.array(text_to_sequence(arpabet, [\"english_cleaners\"]))[None, :]\n", + "seq = torch.from_numpy(seq).to(device=\"cuda\", dtype=torch.int64)" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [], + "source": [ + "model.eval()\n", + "_, mel, _, alignments = model.infer(seq)" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [], + "source": [ + "MAX_WAV_VALUE = 30000.0\n", + "tensor_cls = torch.FloatTensor if not torch.cuda.is_available() else torch.cuda.FloatTensor\n", + "y_g_hat = gen(tensor_cls(mel).to(device=\"cuda\"))\n", + "audio = y_g_hat.squeeze()\n", + "audio = audio * MAX_WAV_VALUE\n", + "audio = audio.unsqueeze(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [], + "source": [ + "from IPython.display import Audio" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Audio(audio.data.cpu().numpy(), rate=22050)" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(80, 959)\n", + "(165, 959)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pylab as pylab\n", + "\n", + "alignment_graph_width = 1800\n", + "alignment_graph_height = 720\n", + "graph_scale = 1\n", + "\n", + "def plot_data(data, info=None):\n", + " %matplotlib inline\n", + " fig, axes = pylab.subplots(1, len(data), figsize=(int(alignment_graph_width*graph_scale/100), int(alignment_graph_height * graph_scale / 100)))\n", + " for i in range(len(data)):\n", + " print(data[i].shape)\n", + " axes[i].imshow(data[i], aspect='auto', origin='bottom', \n", + " interpolation='none', cmap='inferno')\n", + " axes[0].set(xlabel=\"Frames\", ylabel=\"Channels\")\n", + " axes[1].set(xlabel=\"Decoder timestep\", ylabel=\"Encoder timestep\")\n", + " fig.canvas.draw()\n", + " pylab.show()\n", + "\n", + "plot_data([\n", + " mel[0].data.cpu().numpy(),\n", + " alignments[0].data.cpu().numpy().T,\n", + "])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [ + { + "ename": "ModuleAttributeError", + "evalue": "'ModuleList' object has no attribute 'requires_grad'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mModuleAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mencoder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconvolutions\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrequires_grad\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m~/anaconda3/envs/pytorch_p36/lib/python3.6/site-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m__getattr__\u001b[0;34m(self, name)\u001b[0m\n\u001b[1;32m 777\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mmodules\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 778\u001b[0m raise ModuleAttributeError(\"'{}' object has no attribute '{}'\".format(\n\u001b[0;32m--> 779\u001b[0;31m type(self).__name__, name))\n\u001b[0m\u001b[1;32m 780\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 781\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m__setattr__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mUnion\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mTensor\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Module'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mModuleAttributeError\u001b[0m: 'ModuleList' object has no attribute 'requires_grad'" + ] + } + ], + "source": [ + "model.encoder.convolutions.requires_grad" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n", + "True\n" + ] + } + ], + "source": [ + "i = 0\n", + "for param in model.parameters():\n", + " print(param.requires_grad)" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [], + "source": [ + "for param in model.encoder.parameters():\n", + " param.requires_grad = False" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "for param in model.parameters():\n", + " " + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Environment (conda_pytorch_p36)", + "language": "python", + "name": "conda_pytorch_p36" + }, + "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.6.10" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From 8b3ad6be8253901caacd56036e50442c834914b3 Mon Sep 17 00:00:00 2001 From: Ubuntu Date: Sun, 14 Feb 2021 01:51:58 +0000 Subject: [PATCH 03/16] add tgraphs --- .../SpeechSynthesis/Tacotron2/Samples.ipynb | 455 +++++++++++------- 1 file changed, 276 insertions(+), 179 deletions(-) diff --git a/PyTorch/SpeechSynthesis/Tacotron2/Samples.ipynb b/PyTorch/SpeechSynthesis/Tacotron2/Samples.ipynb index 6f1e499e9..36e6fd4ef 100644 --- a/PyTorch/SpeechSynthesis/Tacotron2/Samples.ipynb +++ b/PyTorch/SpeechSynthesis/Tacotron2/Samples.ipynb @@ -146,77 +146,18 @@ "output_type": "stream", "text": [ "michael rosen\n", - "checkpoint_Tacotron2_1000.pt checkpoint_Tacotron2_1920.pt\n", - "checkpoint_Tacotron2_1010.pt checkpoint_Tacotron2_1940.pt\n", - "checkpoint_Tacotron2_1020.pt checkpoint_Tacotron2_1960.pt\n", - "checkpoint_Tacotron2_1030.pt checkpoint_Tacotron2_1980.pt\n", - "checkpoint_Tacotron2_1040.pt checkpoint_Tacotron2_2000.pt\n", - "checkpoint_Tacotron2_1050.pt checkpoint_Tacotron2_360.pt\n", - "checkpoint_Tacotron2_1060.pt checkpoint_Tacotron2_370.pt\n", - "checkpoint_Tacotron2_1070.pt checkpoint_Tacotron2_380.pt\n", - "checkpoint_Tacotron2_1080.pt checkpoint_Tacotron2_390.pt\n", - "checkpoint_Tacotron2_1090.pt checkpoint_Tacotron2_400.pt\n", - "checkpoint_Tacotron2_1100.pt checkpoint_Tacotron2_410.pt\n", - "checkpoint_Tacotron2_1110.pt checkpoint_Tacotron2_420.pt\n", - "checkpoint_Tacotron2_1120.pt checkpoint_Tacotron2_430.pt\n", - "checkpoint_Tacotron2_1130.pt checkpoint_Tacotron2_440.pt\n", - "checkpoint_Tacotron2_1140.pt checkpoint_Tacotron2_450.pt\n", - "checkpoint_Tacotron2_1150.pt checkpoint_Tacotron2_460.pt\n", - "checkpoint_Tacotron2_1160.pt checkpoint_Tacotron2_470.pt\n", - "checkpoint_Tacotron2_1170.pt checkpoint_Tacotron2_480.pt\n", - "checkpoint_Tacotron2_1180.pt checkpoint_Tacotron2_490.pt\n", - "checkpoint_Tacotron2_1190.pt checkpoint_Tacotron2_500.pt\n", - "checkpoint_Tacotron2_1200.pt checkpoint_Tacotron2_510.pt\n", - "checkpoint_Tacotron2_1210.pt checkpoint_Tacotron2_520.pt\n", - "checkpoint_Tacotron2_1220.pt checkpoint_Tacotron2_530.pt\n", - "checkpoint_Tacotron2_1230.pt checkpoint_Tacotron2_540.pt\n", - "checkpoint_Tacotron2_1240.pt checkpoint_Tacotron2_550.pt\n", - "checkpoint_Tacotron2_1250.pt checkpoint_Tacotron2_560.pt\n", - "checkpoint_Tacotron2_1260.pt checkpoint_Tacotron2_570.pt\n", - "checkpoint_Tacotron2_1270.pt checkpoint_Tacotron2_580.pt\n", - "checkpoint_Tacotron2_1280.pt checkpoint_Tacotron2_590.pt\n", - "checkpoint_Tacotron2_1290.pt checkpoint_Tacotron2_600.pt\n", - "checkpoint_Tacotron2_1300.pt checkpoint_Tacotron2_610.pt\n", - "checkpoint_Tacotron2_1310.pt checkpoint_Tacotron2_620.pt\n", - "checkpoint_Tacotron2_1320.pt checkpoint_Tacotron2_630.pt\n", - "checkpoint_Tacotron2_1330.pt checkpoint_Tacotron2_640.pt\n", - "checkpoint_Tacotron2_1340.pt checkpoint_Tacotron2_650.pt\n", - "checkpoint_Tacotron2_1350.pt checkpoint_Tacotron2_660.pt\n", - "checkpoint_Tacotron2_1360.pt checkpoint_Tacotron2_670.pt\n", - "checkpoint_Tacotron2_1370.pt checkpoint_Tacotron2_680.pt\n", - "checkpoint_Tacotron2_1380.pt checkpoint_Tacotron2_690.pt\n", - "checkpoint_Tacotron2_1390.pt checkpoint_Tacotron2_700.pt\n", - "checkpoint_Tacotron2_1400.pt checkpoint_Tacotron2_710.pt\n", - "checkpoint_Tacotron2_1410.pt checkpoint_Tacotron2_720.pt\n", - "checkpoint_Tacotron2_1420.pt checkpoint_Tacotron2_730.pt\n", - "checkpoint_Tacotron2_1430.pt checkpoint_Tacotron2_740.pt\n", - "checkpoint_Tacotron2_1440.pt checkpoint_Tacotron2_750.pt\n", - "checkpoint_Tacotron2_1450.pt checkpoint_Tacotron2_760.pt\n", - "checkpoint_Tacotron2_1460.pt checkpoint_Tacotron2_770.pt\n", - "checkpoint_Tacotron2_1470.pt checkpoint_Tacotron2_780.pt\n", - "checkpoint_Tacotron2_1480.pt checkpoint_Tacotron2_790.pt\n", - "checkpoint_Tacotron2_1490.pt checkpoint_Tacotron2_800.pt\n", - "checkpoint_Tacotron2_1500.pt checkpoint_Tacotron2_810.pt\n", - "checkpoint_Tacotron2_1520.pt checkpoint_Tacotron2_820.pt\n", - "checkpoint_Tacotron2_1540.pt checkpoint_Tacotron2_830.pt\n", - "checkpoint_Tacotron2_1560.pt checkpoint_Tacotron2_840.pt\n", - "checkpoint_Tacotron2_1580.pt checkpoint_Tacotron2_850.pt\n", - "checkpoint_Tacotron2_1600.pt checkpoint_Tacotron2_860.pt\n", - "checkpoint_Tacotron2_1620.pt checkpoint_Tacotron2_870.pt\n", - "checkpoint_Tacotron2_1640.pt checkpoint_Tacotron2_880.pt\n", - "checkpoint_Tacotron2_1660.pt checkpoint_Tacotron2_890.pt\n", - "checkpoint_Tacotron2_1680.pt checkpoint_Tacotron2_900.pt\n", - "checkpoint_Tacotron2_1700.pt checkpoint_Tacotron2_910.pt\n", - "checkpoint_Tacotron2_1720.pt checkpoint_Tacotron2_920.pt\n", - "checkpoint_Tacotron2_1740.pt checkpoint_Tacotron2_930.pt\n", - "checkpoint_Tacotron2_1760.pt checkpoint_Tacotron2_940.pt\n", - "checkpoint_Tacotron2_1780.pt checkpoint_Tacotron2_950.pt\n", - "checkpoint_Tacotron2_1800.pt checkpoint_Tacotron2_960.pt\n", - "checkpoint_Tacotron2_1820.pt checkpoint_Tacotron2_970.pt\n", - "checkpoint_Tacotron2_1840.pt checkpoint_Tacotron2_980.pt\n", - "checkpoint_Tacotron2_1860.pt checkpoint_Tacotron2_990.pt\n", - "checkpoint_Tacotron2_1880.pt checkpoint_Tacotron2_last.pt\n", - "checkpoint_Tacotron2_1900.pt nvlog.json\n", + "checkpoint_Tacotron2_360.pt checkpoint_Tacotron2_600.pt\n", + "checkpoint_Tacotron2_380.pt checkpoint_Tacotron2_620.pt\n", + "checkpoint_Tacotron2_400.pt checkpoint_Tacotron2_640.pt\n", + "checkpoint_Tacotron2_420.pt checkpoint_Tacotron2_660.pt\n", + "checkpoint_Tacotron2_440.pt checkpoint_Tacotron2_680.pt\n", + "checkpoint_Tacotron2_460.pt checkpoint_Tacotron2_700.pt\n", + "checkpoint_Tacotron2_480.pt checkpoint_Tacotron2_720.pt\n", + "checkpoint_Tacotron2_500.pt checkpoint_Tacotron2_740.pt\n", + "checkpoint_Tacotron2_520.pt checkpoint_Tacotron2_760.pt\n", + "checkpoint_Tacotron2_540.pt checkpoint_Tacotron2_780.pt\n", + "checkpoint_Tacotron2_560.pt checkpoint_Tacotron2_last.pt\n", + "checkpoint_Tacotron2_580.pt nvlog.json\n", "trebek\n", "checkpoint_Tacotron2_350.pt checkpoint_Tacotron2_500.pt nvlog.json\n", "checkpoint_Tacotron2_400.pt checkpoint_Tacotron2_550.pt\n", @@ -235,7 +176,7 @@ ], "source": [ "print(\"michael rosen\")\n", - "!ls output_michaelrosen/\n", + "!ls output_michaelrosen2/\n", "print(\"trebek\")\n", "!ls output_trebek/\n", "print(\"lj\")\n", @@ -244,16 +185,16 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ - "checkpoint = torch.load(\"output_michaelrosen/checkpoint_Tacotron2_last.pt\")" + "checkpoint = torch.load(\"output_michaelrosen2/checkpoint_Tacotron2_last.pt\")" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -262,7 +203,7 @@ "" ] }, - "execution_count": 10, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -273,14 +214,14 @@ }, { "cell_type": "code", - "execution_count": 51, + "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "{AY1 D} {JH AH1 S T} {L AY1 K} {T UW1} {IH2 N T ER0 JH EH1 K T} {F AO1 R} {AH0} {M OW1 M AH0 N T} . {W AH1 T} {Y UH1 R} {R IH0 F ER1 IH0 NG} {T UW1} {AE1 Z} {L IH1 N AH0 K S} , {IH1 Z} {IH0 N} {F AE1 K T} , {W IH1 N D OW0 Z} {S AH1 B S IH2 S T AH0 M} {F AO1 R} {L IH1 N AH0 K S} , {AO1 R} {AE1 Z} {AY1 V} {R IY1 S AH0 N T L IY0} {T EY1 K AH0 N} {T UW1} {K AO1 L IH0 NG} {IH1 T} , {D AH1 B AH0 L Y UW0} {EH1 S} {EH1 L} .\n" + "{AY1 M} {IH1 N F AH0 N AH0 T} . {Y UW1} {HH ER1 D} {AH1 V} {HH EH1 L} ? {W EH1 L} {AY1} {W AA1 Z} {S EH1 N T} {F R AH1 M} {IH1 T} .\n" ] } ], @@ -290,15 +231,15 @@ " # \"Never gonna give you up. Never gonna let you down. Never gonna run around and desert me.\"\n", " # \"What the fuck did you just fucking say about me, you little bitch?\"\n", " # \"Loads to eat, I had cod and chips, the cod was huge and there were hundreds of chips.\"\n", - " #\"I'm infinite. You heard of hell? Well I was sent from it.\"\n", - " \"I'd just like to interject for a moment. What you're referring to as Linux, is in fact, Windows Subsystem for Linux, or as I've recently taken to calling it, W S L.\"\n", + " \"I'm infinite. You heard of hell? Well I was sent from it.\"\n", + " #\"I'd just like to interject for a moment. What you're referring to as Linux, is in fact, Windows Subsystem for Linux, or as I've recently taken to calling it, W S L.\"\n", ")\n", "print(arpabet)" ] }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ @@ -309,7 +250,7 @@ }, { "cell_type": "code", - "execution_count": 53, + "execution_count": 22, "metadata": { "scrolled": true }, @@ -321,7 +262,7 @@ }, { "cell_type": "code", - "execution_count": 54, + "execution_count": 23, "metadata": {}, "outputs": [], "source": [ @@ -331,7 +272,7 @@ }, { "cell_type": "code", - "execution_count": 55, + "execution_count": 24, "metadata": {}, "outputs": [], "source": [ @@ -345,7 +286,7 @@ }, { "cell_type": "code", - "execution_count": 56, + "execution_count": 25, "metadata": {}, "outputs": [], "source": [ @@ -354,7 +295,7 @@ }, { "cell_type": "code", - "execution_count": 57, + "execution_count": 26, "metadata": {}, "outputs": [ { @@ -362,7 +303,7 @@ "text/html": [ "\n", " \n", " " @@ -371,7 +312,7 @@ "" ] }, - "execution_count": 57, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" } @@ -382,20 +323,20 @@ }, { "cell_type": "code", - "execution_count": 58, + "execution_count": 27, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "(80, 959)\n", - "(165, 959)\n" + "(80, 352)\n", + "(53, 352)\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABBwAAAGpCAYAAAAupCVkAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOy9W4xkSXqY9/1/RJyTmVXV3dM9M7vcXd4prkSKS5nepUnDlChaIkHZJukbQRECZOiBgC0TMGAbkmXA9oNJ0H6w/WBAAA0QupmyKZGyJZg2aAmmDMq8mBeRWnKv9N64Ozu3nr5UZeY5J+L//RAns6prqrp7Zrpnpmfja2Rn5blExIlbZp6M+ELcnUaj0Wg0Go1Go9FoNBqNR4m+1QloNBqNRqPRaDQajUaj8c6j3XBoNBqNRqPRaDQajUaj8chpNxwajUaj0Wg0Go1Go9FoPHLaDYdGo9FoNBqNRqPRaDQaj5x2w6HRaDQajUaj0Wg0Go3GIye+1Ql4GA7C0m+kQwQQqdsmE9ZZyG4UMToC7z3cMuXIpkTM692Ua8s1IRZKCZQSGHLk9hgRgSAQxAkC5rApQnYnifDsasuYI5sSKC64gwNbc9ydq0k46kaGHNkW5bhAJ8KVrpBNcBdE6gog5sJkwsYccyeKcJQgilFc2BRlMscBO7NqSBAhiqDzNTtQHPJ8TBTB3Rm94OKIK0sNGDBaQRBUhDBnmu7DcIo7IkIAggpKzQ8Rx1wwr3EVd2Q+Zpc0hzk/fP96l27DUWp8IjVcneM3d1R24dT4AQRQqfG5Q2EX0Wn4u7jYn+Hzcw1f5vxydwrg7oR5uwM2h+fzcWfTwbzf5/Nkvo6z+Sf7MoGozkEsqBjbHDnOymhGloJhBEItH0K9tjmNxR0DihsARQqFCXcDEeo/xTyDCO6GiM55lwkS2a0qIyJzeo1d6oxa5jWWGla9QptzTedzFSXM5+1iVcQFRRDZ7YFFkPm6nSiOCGyLsi01HQcRejUcmExZxsyiGxFx3IVxSqynxLoIWytciYHriw0AY0mscyCps0ojgnN7WOBAFOfmCFkKHZGDCMtQKK4cT8rGCiaGuhJEiSL0CoLXNmW1HJPWaxnMWXPCdT3kWjch4mxz5M6kTF72eehn6lNxw8QxjPp/wd0wMu5OpysW9CQVopzG7fs2cVq3g9RrOuxGYqj90d2xY5rbWrZdnav1MwgkrXmeXdgWYTQjqbIIzkHMLPuhtteiTDlxMiW2JmSrbUCAXoU490ODCWufeG9fr3VTAjant3hN79VUMIShKIPBZLV/3bVAw1jQYXNb2rUvxzGpeVTImE+4F67oDb5sOXIyddzNkN24lhQVZzIl+2m7j1rzarLafyXRfauf3FiFQK/OS3kiM851VPd1uJaR4W44ZW4rZU5h4Nl0A53L6KRkOokkZV/fVHb9mmDMZeKn/VQUOEqZLhTMhW2O3M3K1jOFgmNzOvxMffIz7e+0Te72yb5XPj1i/88Fl10IZd6/C9P3oRQbKD4KjTcF2b2xNxqNdwC7d7EvZVoeNB4d7n7h55En4obDtXjEf/QV/wa9Gp0aBjy3WfBPbyovTgN3ZM179So//m0f5Qs3b/B7r9xgXZSFGj/wTb/NlRu3OL51hVu3rvKpl5/hH3zuOlHheu9cS4WDaKyL8pHbkee3E+9ZJv79D3ycz9+6zu+88hR3J2VThMngE8cjgxf+zLsTf/LLP8unbt7gI7eP+JWXC+9dJr7nPbd5abtgW5QuGArczYEvbiK/e2dk65lroee73mXc6AduT4kP3+p5YWsMZmwtk3EiwlFIXO8Cy3j6QfzO6Lw0TSjCtRSZzPlsvs0kEwtf8A3LKwzmfGo4piexkMD1rhbzIgjF4dZYeKWMLCVyEALXe2UR4EpyOnU2pd7MuTPBzbHQq3CtU4ZSP+wWgzzf+LD55sWxZQA2jPQkAJYS6VRZhfohe1uMRVBsvlnRaU1Pp8IiwJ3JMYc7OdevePOX6wljIu/rQySQKcT5i/1KEkmEgxgo7tzOmeLG1dgR5hsZxyVj7kwYN2LPMtTyLHMcoxmT+/7L55aJnshKI1dSmL801htFzy4K33LjJkf9lo/dfJp/8uKSz2y2vKg3Gdhy6FcAeIYrBITDGFgE4SQ761J4xdcA3NHb3OJ5RlujEkiyJMmCu+UFgiSybYm6QFDW+WUO0jNkG2oeaI95ZrI1KjW/x3KMSiLbBhGl04Oaf7bBMZIuEZSkK1b6FIoSPJHoWPqK5JEDOpIEktQbD3/4Si27a53xTD8S1fj4nRUfuV2/RH3wBvyho2MmV55bL/mm6y/z/i//LF0/Mk2JT3/+vfzmi8/yW69EPr69w3ffuMIP/pGPAPDZl5/hn918inctB/75934OEePnP/n1TCa8azHytz4Lr8ht3ssNvu3pwAeeusWtseeXXjjgw+vbbGTD0pdclSXPdImvOaw3Rm5PykfuTAQR3rOMRIFPnUz8Br/KDx79S/xrX/FF+jjxsZtP838+t+APptpWbP4it5JEEOG2bTmRLVtZM8iGjd9hsGO2+RbFBt6z/CDf4F/Fu5eRG31tOy8PtX5nh7uTkxQOo3CUnGf6wne873M8fe0WN29f5R9/7iv44jZyd4Jbo3NSCkGE613gKMG7FoVn+okXh8TH7wQ+s93wvn7BH75qfOjpl/imr/skGozNyZIvvPgsv/bFL+MTdxMvDcbtnAkIX3OYeKavZfX7x8JvD8/z4++PGMLv3LzGUOqX/pcHYVvge997h02OfOp4ySfuwnPjlmPZ1JsIGBtZ8/V8BVvLTGe+YA9MnOgJG1lz117geHqeMd/kX1z+2/yVP/Z5fvW59/CLLygvlTXf/+4lR7Hw3Kbj+W1tF5PB9V44iPDc2vn0eMyXxQOc2s88X475lsOrfO3RxE89/zwv+WcRURILgiQCkdE3jL5mtGPGckKxDcVOcB8JepUffvqHOIjGy4Pya3df4avTNZ5Z1H7g3UtjEZyxCMWFdRFe3MKmWL1BCTy9EL7zXa/w5dduspk6PnbzaX7x+QW/N77MsdxhkgFFKWTC/NZayEy+BSCQSNLv+zHDSN5TZEIIqCuRSCDS+4LogVEmJhnZyBp1RVEmGfY3wYpPvLz5p6//zbXxOgnzc/ug3ngreKP1rtXbUwL1xvRbxe672VtZHoHTn93O8k6sJ5dd0+u51re6Hb4dy+fytvRE3HBoNBqNRqPRePvxVn9hebN5O3xBOsvZD91nf1i77EvFw3A2vIe9zvvF/Xry7H5xv94vRmfT8Xb8svJaeFTpfxRt942k5e1QBrsxkU8iu3HEF90wuYj7HfNGbjq83jpw2c2e83Fw7pjz5TWPWhbFvSAScC9njpZ7RopfNBrz7DFyNnzZjczUM+cHnILMN9+dCZUl7ieXXkVzODQajUaj0Wg0Go1Go9F45LQbDo1Go9FoNBqNRqPRaDQeOU/ElIoqP7O9hFFh7wGAOhc2ihDUkFkACbN0LWXiYiClib4b6UIhKvQBlqHOu96xk/sFga4b6WMmzDKx3eCSXhRzJ8xpSVrnRwepHoJFzKg4W1OSOojjDqPB4FUqCHDeO7WTxe20YEkCQYQuQDffFhKtHoaU9UwesM8Dx/cStkEmzJ2eJb0Kh3WaP5tyKnGEWacmp4OSkjrZhF7PyB/nVKnAWHaDf3wvgRzM5jQ4VYMoRALGaXllZxYm1m2zc3Bfjo7sy+00bV6FgC5Mc/gR3eehYShKEqFTZTF7GRShsJNrCuanPohdus86TcLsK5BZ6phEUFeEKoxMs1RTpIrjlsFYpolFmliEMg/m2l1r/Vev0VAJVb5pNT2Tl71cMpOriBCr+SC2T5N53b7zONRj8nwN90og93VIFPNp/7rsRJOzSK/4RJznkNcwFBOjeKaQQSB7Ai9AQNxxV2YFB4Mp5sJoO0klFBcMmeWrzjJNdP1I7Ks4ctUPBD0dtiXiqBpBDRVnsBq4aiGokcRRrS6GiUIg4sBowlgC7lWierYOmFcHwLZUmeZJZi9KXWenV2HyWjODQB8nupjp1EgKPQnlVFZqOGeb52lcBUGr5HOf5zthZK3no9U4R3O2xViGwCJUGWFS52CxYXVwwjAmumB06vRBWARBJRAEFuFUMhnU9tJHqOGYC0GdEAsaMzElYqhD52pfJbOutObJ5LLvLxRl1Y2Ms6xztOqLUWEvp7XdwyGh9J4oBLIUMnmvaQy7ej4Pxds5BnaiUyHQq9Zy1SrjTUQWwQjiVSx6Ju51rtc9ee17dv4G96qDjHM9jB4JkvblUR9hn0dyJg34rr+t/fHZfCjuTFYdEnen+vpsHxRl7m9FCAr9LDc9XK0JW+MgZtKcaSan9XF37U7BvKBn0rbblxn251WXQ8LEEFfUdd8e9yJMCiZQmChkik+zoHOahZKNt4admPRLibfDEPCz+CV/P+jY1xr2Gzn29eTZo8xnP/f8qMN/K3g7pf9Rp+X8cPk341oviuPtlMf3Z/eeW3mz2ttlzouHnV5RVdyvr99SYrhCLncQhC49y9XufYy2ZpNvEnVJtg0qEfOMu6Ea67PUr/4iSpBE0hXmBfOJqIv99w7zQq+HOMYVnkFRRhkBWPsrHHIDgC3HLDhkwx1ubT586VW0EQ6NRqPRaDQajUaj0Wg0HjlPxAiHRqPRaDQajUbjch4kjfxS4Pyvqxf96vqkCyPfTjzOvHxcIyceZpWGt6KOvHZJax3Z4GdGN7zWcHa8Xvnv2RGMu9GvDxe3SAdu+JlV+C45krpgdzwVPYpSbFNHm4Yjvi59Ox9avJt3L52P3nZ+yz/Bi9MnEQLmeR7luWSyDSqJ4sN+xLMwLy+vfV1NKyw54gZBIp13ZKmrlEWPJO840WM6WbG0VR3RLXDFr9HLgtsXr4gJtBEOjUaj0Wg03gGIyE+JyAsi8uFz239URD4mIr8rIv/1me3/iYh8ct73PW9+ihuNRqPReOfTRjg0Go1Go9F4J/DXgP8e+Bu7DSLyJ4HvBz7g7oOIPDtv/wbgh4BvBN4D/EMR+Xo/u5ZY4wmj/Wr/6jx4J/obHpbX+yv9aznvceTlWzFi4rJ682by2p0pDx4d8LC83m7/9b9duI8PeyTMS1aqroh6wHsW38xffPYr+Q/+6v9Guf4sL/93H+ff+rlDfn77EQ65wW37IsXGva8BYLLN7HJQiteRDdkH1vllki5RSajWERuv+BdY6lXuMDGxpWO1HyAz+prJNqzlFaL0HOcXOInvZl1eZuO3L72KJ+qGQxKnC4Uyi+N2crTogU6F5WrD6u5QZY1UqdfiYE13tGY4XhFCIYixCHA1OUexVJmZGhTdD4YJAot+4LDf1jjVKaEOaOm0Hter0cWJLhQWwVio0ikcpJErqWMyZRmrYK24kOaxJEYVl+2GlhSvksqDWKVlSmQwI6nSq9Ap9MERqmhxMqHXenYfoOQqvcPZS9xqPMYgI9l7ROAgepUX+j2rqyLzQ6WK+hSfhZbCzi1ZvIokAaLWSm9F9pI5YC+p0zNpCAi9ClGrkDG77GV+QaDX2qmHWbwXBYJCKLVcdacaFAWHeEbICEaaq29SneWOVRiZpNaMOMeVVKBArwH1WoZRd3bReh1RBBchoQTqcxLdy0AFiAqrWOvNYb9ltdgQtcrsegkk7zAx1HfXWM8PUoWTPkspy9xBFpkwy3vR42ggqmQbCBL3ksdsW9yrQHInjMy2E1NOqKR7ZIb7ZylQlYCYZ4qNoKCeKD7NnUfGpcoZoxsTiYIgXst5XRKrS94EqmT1VJ66ioWDfku32iKzFFClCgL7UOtnEFgutmgwulDo1ViEQoqZEIygjlmVS0YCnScQmAxGC0yme+mfophUkWjSmsdJq3RxsWsjKvQBFhoJnkjqHC02xJg5SiOLcEASrXXNhSi6P3cqiexGYTHX54SLEbTDrbD0FYdROYzOIvgsdGQWWBqDG2JCX5TQwyIUVssN/eGa5WZBr8ZRsjkndy2xymwBzrhdq6xUIgdJWITCMo2kZc1Hy5EgO3ktc1ua26PU0PtgrGKgH3qWaU0XlF4dD4YhLHLYi1yL1TejKJBEWXoi4xQvTIykoGSvfYUiTA4QKd4zyUggIaLI/EbXhTxLRXftqsoww3x93dwP7OSRQYSVdBxG3YuB72wXc5/hKFrjQFlwSPRax5Eq9iwyzeLICBJhlq0GgWU0DqOwYidPZe4X66NT3+fhmGp/tQxOFDiIhcN+4ODwBFXjII0sA1zxAyYf9+16lJHeq+g1kOb01DfxzjtkX3frEMWOjkBETem935d5IlLOCSd3EsksGacw+uZV8tgvZdz9/xaRrzq3+d8FfsLdh/mYF+bt3w/8T/P2T4nIJ4FvBX75TUpuo9FoNBpfErRPKo1Go9FoNN6pfD3wHSLyqyLyj0XkQ/P29wKfO3PcH8zbXoWI/IiI/LqI/PpjTmuj0Wg0Gu84nqgRDo1Go9FoNBqvgQg8BXwb8CHgZ0Tka3j12nNwyZhed/9J4CcB5Pya1o3GO4rzksmzosHz27jg9f140LEXhf1GuN/595s20Zr4O4f7iTLfaLjn28f94j/P+eMfRlppmN1ltGM+c/yP+EvrJf/x9xwjPE8IV/lA9018rf0REpEbPM1zfb2fPvmWJIs6snlmClsSC0Zf87R8BXd4iSj9/hgRZW11ykSaR/k6RqHuPwrPAnWU9deGD/ECn+Or9Vv4qD53aerbCIdGo9FoNBrvVP4A+Dmv/BpVJf70vP3Lzxz3PuALb0H6Go1Go9F4R/NEjHBwwFxYxsxBGimuXBs7rnY92RMlLzmIQr8Y6OPEQcwUFw7iRLccCMuB2E10/cgiZg6icyUVjlKdcxvVYIqYs3cBdIuBZTdwEOsdp16FtSrPLpTjLCzCREoTfcwcRKPXQB+cFDLLOHFoyiIUdL6LtQyJpUTw6hTY/UgSxFkFZxHqHO51DpzkgAp0Wl0Th6kQxCku9BooXu8TrSIcRCEMB2xKIXudK+9A9ICJswqRax1c6wrHU6AEzsylFhZBOIxOF+AgGstYCFLnyG9NOCqKe/UX1PnVtSx2z8Dsl6hui1AElepfOIqRoyQcxOqOWJTqQxht9mQEGIoQtV5r9upyKFbnLWen+iIctNT51Er9tFjc6VRx95oHsosHjnM9P+luXrYwWJzn5geudbWMJxOy1XgUiBLo5rztXUkqLIOyDJDmud0H0ThKE6vFhtVywypOLAIchsg21yViVixQhJUGktY8TiIkVZIrC693CwdfciJ1/vnOzVCYUNHqZfCMSsIxVCIioS4B5AWVMC9lk4jSI6KYL+9pN1F6kq4QCUyyxt2I0tPpiih9nUeOETzN8+IjOs8wj1Lz4STDKsBCqxNFgaNoXOuqMeRKGum1ENS4kiYOV2v6wzU2RawoMdT202l1jSR1NBghZvo4cZgKvRZizIg4SZxFrHFdC4eMllioolLrh1PrTiIwzunvVFkEYRGMVTCUwElXfRFHqZbd0RhYlae43hWODk8IIXN9ueZa9xS3xkgQIbvT6alvBSIUUBcSHVkzWQZyGFBJXLEjDpKwjMYiGMWFVYRNrnV0cgODRVEW6ixD4eDohMVTdxjXSw5iJruQJHCUhDD3CQpsTejVWYTCQTQOEzzriac650Y/crjYELqpujBWu7pYuJoi2yJkD7PnBqI6q2B0GkgEgtq+jgSBZSh0qmxn78Punv0yChAZLFDcmdw58S1RhGUITGaICBiIC0Zi8I4gqfYLUstAtXo8olSPyjIORHGS+v7ef6e1b+i0tttrMXGjr94cgFtjYhmcTo3kiag9jtH7guQd0QNRIkUnik5MlhBGRBLuEyo9B9E4iIVNVI5Cmh0yzJ6dXTqcKA7o3t9wo8/06ixjZpFG+sUWM2U5t/2VRNZ22vYmmei9xzAmmcjkvWciekBRBhku3N5T885mR03BEBeSJ0yciZEsGfVa901Oy7JxKf8L8F3AL4rI1wMd8BLw94GfFpH/hiqN/EPAr71lqWw0HguvVZx4XjJ5kWzyjQgGH3TsmzW6oI1ieGfwoBEGj1vA+aClZh82/otHN6gc8KHFv8kfv37IH712zA//hz8NwN3ffC//5c/+K/y3X/wp3CdKuc1vbX+upkQSKh0qCavqoro05s5tRXWHiShmI7f4/+p3EDcQ3Xuh3PO83Ojuc4ae/u22X6LzOQqgPM+vwn0knk/EDYdGo9FoNBqN+yEifxv4TuBpEfkD4D8Hfgr4qXmpzBH48+7uwO+KyM8Av0f9lPQX2woVjUaj0Wg8etoNh0aj0Wg0Gk887v5nL9n15y45/seAH3t8KWo03mraL/mNdzJvl/r9KNMRuLL4On70me/ie7/ys7z76Y/yxZee4cMvvosv+9Fv5s7webLdxO0n98uCzmvuzUkxnEy27X61sLOrWan0qEZy2aDa1VM849j+gZ8dPXm6OuD+tYDMxwhhXlHs/paG5nBoNBqNRqPRaDQajUaj8chpIxwajUaj0Wg0Go0veR5mFYnz89YfdpWK+4V7Nv4341frh4nncablYcN+UB6/XX7hf9S8lrx/LfXvUeXXLn3hkr2ydxzUDbvf96sHwX08c3Qg6CHFbs/hGne2n+THPvdJfvxzsytPqyfKbI3IHKdE8Dyfo4j0qHT08RpAdV15oXgdBVF8QFCKjRQbZkdcmUcoGCKKiuJuiCo+n+e7kQzzvvp33G9TSRQbiGHJMF3uXX4ibjj4/Ihie2nkU/3AldSzzsKmBBYB0mLgYLnhxmLDZIHDNBBXW7SfCN1EvxhIs+RxEYxODRVHxAniOE6SKmvrFgMpTaxiRmeZ27IE3BMgRDViKKy6gWvdyGHqOIiFZRo5SIniyiJkghoisIo9qxCgVEFamuPs1YgKUZyozpUEdyZlmsWKh6lwLdVw3Ot5g0V0FhiuswLCSQ6ss9NplTmuWBBdeNci8OWriae6kRfogUAfIGVlEaps7yAaUZ1lLFzvRoaodFOieCKbkL0KKpM4IuB+KnPbadf2cse5SiUVDqNwJcEi1ME2nQp98CqKlCqqTAJB6/NkVdiXvTbRbDUGEQhTFUqKwGg1rlUUisFhFFRqPMVgEeqxUWsYUWdxX6ipXcWa7iAwCgSHKIJR86547dyDCH2APjgLrde+UCOqEdQIsRDVSFrP7wiYd/QSCAiLoFVAqlWy2akQiuzFcCs/5K4sMM2Yl71sT+VUirfblmUgSKqCSTGSLEmyQERJLOp2PTMcCki6opPVPgzziaQrejlk5UcATIwkOqJHOk8kIja3g8mdk2w81SlpFhgGca51hRu5dp4H8bSOL+NE3w+EfkLUUFNSmkjiJIUkShAnpSo7DGq1/gcjpkyMmYOY5zKauN4Fbo6gIphDNiV7LWuAQsbEiFK3JXWWsV77UYoItY0AdKp0eUmnTtcPpG5i1Q8cRePqbIkcrNbbpGBez1l6wC2hLkx2yCCRUQ8BiIS5m5+HikkVi8o+fYa5kz3SBWcRMrEfiQdbYj/Sh8LClCg+i1hrPzO5UKaAORTTuU7AQYSDOJdDKIg6mjI6RcJcL7tgqASiQBfqtag4i2B7GWYxpZjW8M+89xaHsQSOc2BT6kV0QebrETbF0VIFnjILdnd9gIqgriSqNFLl9K0lhEJSowtCf0amqzjF4e7kHMbaRiareR9379Hcm0YVR+d/Mrej6IFEJFNm+WltP8UHxE4H8XVqHMXMmJRrKeH4vk8xZ86PWpfK/Fqllm2Vd2ZiKIQu09tAF0rtt0XofSd7dPAqSDUMwwkeiR4Ic6oD1ewbqNuhSlDrs84fVJQgSnBBECYEc8fEyGSSd3N8TRrZaDQajUbj7U2bUtFoNBqNRqPRaDQajUbjkfNEjHBoNBqNRqPRaDQaj5PXsmzlZctkPs7438x4HmdaHjbsx5HHTwKPcqnVx8EuzosXNnpVqd03iYVitxEi/9zyB/lT16/xX/zI3+K5334/f/3XP8j/8PLv8MX1b8zTJ8B9QiRxKnF0wHDbkDkml5sPSPvZsQbn5ZAPO2ry1ReUS72Wh4m10Wg0Go1Go9FoNBqNRuOR0EY4NBqNRqPRaDQajUaj8aYwyx4RQjjif/zGP8O/+gM/z63ffx9//Ce+j9/Y/gzw27gX7h3NUEc53DtmwOelKc8LWC/i7CgGP7f98Y0WeTJuODhMpmxLZJPTrNTyvfRslz0hZUIoHPUDmymh4tgU8RzwEsg5UKwK8CYT7uZY5Y1qZBMmg2kWBlqOmFXJXadVzaWlir2K12IOoUonOy2zFNBZ9AOrnPZJnyygs0wuyGnxO1VQVlxwYFugo0ohdXabOlXQWFxw05oHprNcsV7DpshetFZlhzWelUSWIfDuhfOe1Zooxp0pcTcrxWrYOymayCytFKcLhSDGSY6I1HTswkfq8TafC+wFfmf/VpG9UM6p4kaR+ZrttLxqfldjW6getX1cKrUsggjqtSkFlX2ZC8z21yqey16lk2XOh5oG8N2ytHNT3BljfS7H4jVNMMv/5JxIz2q4QUAdRhM2ObLZLlA1Njntj3ecicLW8yyQPM2XXX7vjgtzR2EUzAsq1RLrbphPuFe7LAKOUXygeL9PV5LlnOYwh2kUn3CMbMMcb9oLI6updtoLJRWtUjs5LZAsBXNnIpM9MniBDK+Myq0pcBAjSW1/Hbs8MxfchOzKNCUsK4gjs+h0J10193336CanQsQ5ASJOUmOat3fzwYMZ7oHJlLFoFfrhDLJFUbJXhWmnfipenKWrk9XyLu4UmSgu2By+uey73b3o0R21uj27M7ixW504S2aSgWz1MWpmW+DWpMhcb4ZyWn8GJgA2JVJcGS0wbXvKpqeMiWzKSY6MRe/p/rdF2ZZZXhsiN8fInRG6AKtQ83SaEmeZcqTM+TNZbaOLANe7Kjzd90EERJwYytyWd/lT29bkwrbo/jomc0ar7TC7o17bgkmVqxav7WpyYyQzMVJ8wjxjnmv7KjVO3deBWs5Ra0adlELSwAFCNtgWZ3LnMId9nzG44XPaw6xeVN/VYae4UciUubTMJ8zybFkumE9EgaRGUt+380WA48xeqDlara/Fa7+3LcKtKRDmujXOfbuIY78COOIAACAASURBVLPQNqmSLDLN62Eres+zYcj8Vhvm9ioIOgshgb2sNYiSZpt1EMHdia64O5lC9MAgkCWz9BUb1nzpDbVtNBqNRqPxJPFk3HBoNBqNRqPRaDQajUbjESJEfP7R4LWe+Xpv+guhLmWpHe9bfiu/dfMqf+G/us7J8HvAh+ejzo5iOO9YOO9buMyfcP68s6/Pj4I4+7P4+X3nt722624Oh0aj0Wg0Go1Go9FoNBqPnHbDodFoNBqNRqPRaDQajcYjp02paDQajUaj0Wg0Go3Glxx+n+UcK/dOnRDpzsgcz08zODst4TICXXqW93bfzL9+9av5C9/8z/h3fvEu2+mlc+detkzlRVMeLjrmojDut/TlRcvenr321++MemJuOAwmrEvgoASC+Cxhg9Gc7KciuxBqpRlLoLgybXrCnRXjyYJhs2TIicmEE1NCDlxNhejCYEpxZzJj8sA0JrZDX0V1s2RuMmGYy6nK52ph74SIs7MREWcskW2JjGUnuxMGc8osObQ5zsGUu5OwyVUKtwwy76/Sux1CrSKTCSqn+4rXeM/KHB2IszQxiJO0MJbAYMJowtacwQudK8XulSSaVxHabujLThy3q9i7JO0EkXbPuXM1dsdcmLyKLWW2Jk4GMosfMzJL5OrfYc688zJH0Rqpza+zV5mfwqyBhHEWTY7Vx4bP+RcVStk1S5lllDVteiZM43RGk54px+yOaxXJ7c4JotzNkbvbJTEWJqsSw9GMDRODDMgsgyvuFBPKnFd+pqFaVduhBKKeyiBrHitBEq6LvfQx6ZIoZ6WRCzpfIqJ7AWSQhGPofE6Unkg9J+oCrG5L3pO8m1WIRvRIIBK9ZmAkVOmmCws9rfu7dgC1XqlAFwpJrUr2suJehasaM26KWaD4aUUW8SoRVCOoVYGhFnRutzJLH6PW11XkKXQBFqHsZYg9id4XJDr6ICStaYqzHLH4aR3d1SnD6nNRrChlFrCKVEGlz+mMem+bUARFiB4RCXP5RAqF0Zy7k7CYG2Tet5cq4Uwe9/m3LbVfsSlScpjbfmCcpaS1nP20/rvgXtvsujh5Tp/5rt9xJBQkFmIoBDWCVMFjkJpPT3WZg1jLqFMnoXQhU0yJaiwcDmImaWIRhFUoHEZjEcK+nwpSpYpaqtxwFYWh1Jwp7og7Zk7xyERHkIRKRCXWPiiUKqXVWpYy15vDWLiSErdG3fdpuxmUVUg5i3allkES6NVQhM67uc7WepsIjNR6HEioJFQjmIILIvV6d/UrKWDCIjiLIBxEp1cnqLMMRhBY54BS+7Bicu8MyJjp40Sv0KlU0aNHFMg4vVS1JQ6ZQk9CgSQBo8o3Da/HACuNTG6sNNDpaX7s+l8r9T0vEcle28bSOyZWc0/aaDQajUaj8fakfVJpNBqNRqPRaDQajcaXGFXeeO+IgXDumHt/2XcfUVnM5ykiCSHM5+n8kEsfMVzh+1Y/wC/86Zf5xqtr/uj//sv8v5ufptgdTuWP+594L0jzg0Y3nI3vous4v4Tm+fMu+/v84+FpNxwajUaj0Wg0Go1Go9FoPHKemCkVjUaj0Wg0Go3G/Zdv48y+y86931zk17L020XztV//0nEPF9eDwj2fN68nj94uPMx8+Pude786cFm458+73+vXvyzi5el6u5fJo+ONLUepqCww33Kxl+DVbfLa8hu5vflo3aJL3AfcJ/DMq/M9UEcbCEGvUOx4H89XHX4339l/Hb+0/TQn3OKl4eOYjfi8X2X39VpRSSzTdRZ6hQ/4BziKgf/0g5/gky/d5l/4hYlXNn+HGJ8il9uzF+Js+ncT6p1XL3t52ZKWOx40puDshPLzyH32nU/fw9XXJ+KGgyGc5IBS52n3aqxLYJNhsF3h1mNFnCFHNjkR1Zg2CzQY282SzbZnyJGhKDfHekJxOIjCpsjsbzCGAuPQc3dYcjdHxqIYMJoy2mmBmtV54NmUyWo63ZVcArfGnjtjx7bUc14clJOyJeOMFlnPYU5W/Q03x8IqKHSCUOcYJ3E69TpPXqoBoFfjKELUOod+oU4OQocwFCUquIFI9QgMBnfGnk0JbIuyzsKmZAYmegtkD/u56+Z1nv4qZJYxcxADi6B7b4Qhew/B2WqtUv0McDrnfudI2DkeojhFZH+8A4qjIjinx5nX+du13Kv3YDKY3NE5PHfHRPbOiOKOec1LqPPosTr32qmeBsdxr36Me+Kbzy/zcQCD+b4ZBRfWc18YBMyVZQysp47VmMj26gatZ/KpOidOr013wg9AZ1cDXr0NKoHiE6aZSI+IEkgESRSd6OVwH0fnS5a+IhIRlEImy0BhIssWlUQnKzpZ4RQyPRoivRzS+4Leu31YvfckAoHAoSbMnVVQelWuJaUL8/x6F5jbwM45sMmRVchMpmxLZBh7hrsruuWAFWU7dgxz+7iMoF79AzFXB4EaKk5SOIg1fw+isYy1IA6js9LI2pYs6FgGpVOIe2eJ79MXL3CNDEOPBmPIOz9G9R3sSFrrcxQhICCKeaD3nuyZQVYUmWBXd1zYlponQ6nbdrUiokSpHobJlJIDPjtBan2U2r60vk0ldh4HoQ9GUjvjU5n9L0C2QBkToa/pEPHaXwRnFav/YRGcLhgHacJdSOokUUQcR/ZujSTOQp0pCIuQOYiZwxjPuDfm/oHqzogyqxGAYoI6uCuDC9EDgUTSFVm2yK5P9NoWg1RHiojTqdEHp1ehU6mOCYFNUkKWWqYK2ea2KF77fxILX6Eo6kIi0BOZPNH7EgSKTrgXTDPZjahLlNm9M9eLEKjeBql5I1L7kIUKQZxFqK04G5wUJeRIMd33l0GNqE6nSi8652X1WnRay50CkyudBBzoVPf9G1DrF5BECBJYBaUL1coQlH2/5kQms9on2grDWJDI3hwOjUaj0Wg03t60TyqNRqPRaDQajUaj0Wg0HjlPxAiHRqPRaDQajUajctHyba/n3Nez/0HHPq4h8Q8b7kV586QO038j6b7fua9l3/1eP458DXV04KVhnx0y+qSWa+X1TaeoZ4JhXkdSQpiXtdvttjP5t5uSALc2H563CW5rdtMUXp2Oe6c2FLtNLZcAEln7K/xfw8dYcMAz/j7o4aTUJS1VEiqBlT7F6Gt6OWTjtwkkPqGfwa3wp3/lRe4Mv0Upt3EKlre8esrE7jrvx+mUBpF0z3XLPEIXPzfEeN5W18kS/L5jDy7bd3Y50IeTR7YRDo1Go9FoNBqNRqPRaDQeOW2EQ6PRaDQajcYb5lHKAl+LLO9BkruHOedJ5CJx5EWCxIuEjueFiucFaA/ad1m8l4nUzssbL5NMnk3z+fp0UZouC2v3e+JZMdzZ57pPCPf8ki5n4qy2H7nn+WF5mPMu2nf+vPq8++X3Qdf8sOmT+ks1D/qF/WHDvV99u+yMOF/XRddhF4Sg9/z96vy96Nfxi9L3dmnzgkiqwsYL2kqtl3n/+mzZ737JD+EqxU7mY6vPqkrsdD4uICREIiKKu80jFUCkp09Psx2f4+K8O21HImE/SsBxlMBKnuJz61/hh6/9OYLAK+N1PuU3eUm+wBHXWfqKl3meKzxD8MjX2ldzNXZEERZB+NmTj+Kea3iy4mjxldze/N598+tBI292wsk6siGe5q+clT/Of4si8zVd3kYvk6/pmX7jtA+5t62+mifmhkNxuJsD67JgFYx1UW6OhbVlCkZxKFMk58idoefm2HEUM9MUkU3PNHZsh56xBI6z8MLW2BbjzhS40Ue2BdZWGClkh2FMbKbEnSkyFmHyKim8M9YiMCCXwFgi2xJwr2nMObCZEi9tF7w8RI6zcHuEF4fMTTlGUZYlsi21QWyLcpydu2UCEjIpvcp+QMy6KDolOjXu5sDNMTCZEMWZZqHhptSjRzMmC/VaSmZrwqeOEyf5gOJV2Pby4Jz4xEYGek9sS2RdBJkbaPGekqoI02dJ4zrXgTcAXaj5MFrdl80ZzJncSSJszRBgMCFItZwWr38PhVnMVsWRizms4pC0Xovj3J2MyR1zp9cq17xbJra2S+Pc8L1W304V51QcejfnKmec31Cyw7oYvSqDGWEMdCpMBie5duzZfZbyOYZT3AiiswSuit5UhGzKKtYyXo89JznupZYFI0vep2+aw3PqdU7uDFYYySjCxEjxicJUxW8OhYniE6OsTyv/3A+UuUNVAkUmJkYyGUXneOu59QqshkV9bZTa2TIxsGXJEgDDyFJIfu+Hjir8rCK94rAtVdzqDi8PgdvTLLvTnvUsJA3ibMeO7cnqtN2aMhZlnPutnXBPxffCVXcIMSPB9ueY1/Jxr/K84uwlhnrmvdNxtsXZFOH2FDCHrSnbAuMsDk0KN6eBohMnObDZLgA4HvtZ5lhFkTu5J1b/Lu5MbkwYW0ayFAbZUryWw4mecDsfIKTa/SrcmQrHpda/QsZItf5OtS2PY0cZEyVHplnAeZKFrQij1TYa5jxfhCrqnHZpMTjJgeMpsRk7yhTxWZSqalW2ie/fJrdFuDVGkjijKdtS+5VcAlOp/chJDiRNDFbraPYqlaz9Se1btsXZFuMV2xIIDAW2pbb5KqZ1NlbYMrKRDZkB94JTyF7rxJ0pcTLVcO7mRNCapsmEoI7PcsSkNe6tGUMJjHMdGL0wWO1rcw0ZRykyfzRzGGVikE0VqPrAzhYtsy16NOV4StyZ6jVEhduTcnNwktYe7niCw1Qlp2Xu58bi3BwDRynw/s2S7UltO8OUZgltjWlyw3ZCSIMiwuCFgtV+Dqt5j1EoBAKRKrGcZmOtEjG0SiOdff9YhcY17PqO59Qcvt+HzEaj0Wg0Go23nifmhkOj0Wg0Go3G25dH+evhG/EIPMy5b5dfOt8Il82lf9j5+ef9Bq9134POuSje++170Pb7pen8MWdvRpZLns//wi8PjPFe6q+l946S2P0SXPf5mePOj7A4f85uTMXZfa+O97Xk32X4A0Y2vNZwX3tbujj+86Mdzo7osAuPfLhRJ2/Htu64j5fvuyd/7q2Fu/NyuXnP3tPDy/7ZmeYDzo8GGNiOn7/o7HNx1h/roI6sECDFq7wwfQyzE/7u8T8g6ZLimSCR4plbfA4hsOAKJ7yMoLwonyZPW+4OnwHsnpEd5icPGN1w4VVewM5HAXie47h3RNODl7p8EHVUw7293pl475PO5nBoNBqNRqPRaDQajUaj8chpNxwajUaj0Wg0Go1Go9FoPHIe25QKEXk/8D+f2fQ1wH8G/I15+1cBnwZ+0N1feVzpaDQajUaj0Wg0GvfjtQ69v2xJwdN99/796ikdbzwN71TuP5mlAZcLWh/23IdF6dO7CNpxGJ/lO8IHeX7a8v6nl/zNWz/LML2MU/aSxp3Ucs3n69SGeRrCm1+WF7W3R+F9en3X8dhuOLj7x4A/BiAiAfg88PeAvwz8I3f/CRH5y/Prv3S/sARIWgVwm1JFa3cm5bgMDEwYVahWcsBMuZsTr4yRRSh03Ui/2rI9GUkxI+JsCrwyTRwzsN52mPckldm7WeVhMRQOuwGAdRG2RQgCg+3mEMlegLcuAQOKCebCUCJf3EZe2Ajr4nxh3LBhAIHeE4ugHEYjqlFcKO4MZIIp29FIIlzrAuMsPnxFA0md26Pw/NawM1LCIMJou9eFo6xsi3OXLQMDX5yMD2cjeuRrw9PczhMbBgbZMnjP1hJ3p4C57q+neLcXyt2d4KQUilcxY1d2okenV2FdjLWVWfAYGOa5U4NPJCJKh0o16m6K7eWJUQTznQTSKS6M5rP0zxi8itHcahUdmChe1yZWBMM5tlxXKxYhiuztyk4VuB2X+jqKMLmhBoMV7k7CQdS9fNDcZymbUXDSLNAMCL3qfJ3OYIahLIKxTBNdzPShEOZwAkr0iMzpA6o8cBYwnmUn4bSqPEWpUkjbvYF7FT8GSTi2l3r6fIbRk8mMsiHSn7YVUVTSnK8TmaEKKedzMwOjBLJc2Z9jGBmjm2V1SJ3HWdw5yXUmZqdC0lpHbk/CncmZrPp6T3LHaPBUZwiO6CzAC0YfJ5LWWZlRqgB0t1/EyXOdQx3LscoDXRgtcmdy1sXQArfGKks0F9ZZqnxTJsSFuzkTJZJU2RRhKMJJdm5PmXUOrKKwZpzlmVWwqGokLXRaZaCTVRGiIJgySwMdxxmYONETAEZfk32g+MArPEckUqZrbEokiHCzDGQK0QMmp/PkTjJ7USx7+akwlrrPHdalXm+UnZAzIMA6C+tSGKzw6ZOOden4uqtdLVMTRJyUprksa9lNVgW32xIYipIdbo1CdsMRdBZDHk9CtsSmyCxvLSxCTV9Nm3NcMq/4CXf0Nk/Zde7mnslq31MFl1VgmKUwycjk2ypt9MxgthdUbs0Z3Lg1JhS4NVZZrzmszYlZWEXhJBsnZSJNQtLa32yYyNbP9djJkvd1uvcFmUiZP/SaF8zLXu65O25dlHVRPr8OPD9krneB4sKtPOGbyGDOrTKw2EaOfSARGZhQhOWYuBY7NjmRx4SZki0wmlSppmWO2ZCIGE70KoEdmDBx1IVJJpInTKr0MhBJHtnZnQG8ONMsww0iuDv5jLy0UJjm6xyYmGR6yDm8jUaj0Wg0Gm8Nb5Y08l8Gft/dPyMi3w9857z9rwO/yANuODQajUaj0Wg0Go1Go1F5nDfc60p7KV7nr7zn+/j3vvsfcu1bf4Nf/mvP8if+n1/glzbTmWN1ljSyf75XznhROgNvzciHt4Y3y+HwQ8Dfnv9+l7s/BzA/P3vRCSLyIyLy6yLy62vbvEnJbDQajUaj0Wg0Go1Go/EoeOw3HESkA74P+Duv5Tx3/0l3/6C7f3Cly8eTuEaj0Wg0Go1Go9FoPIHU6ef1IWcebyzMpw++hb/7zT/I+q/e5Ol+4tt/+v10P5L4E//k/5iPcUDrcpmSiOEKQQ/3D5XVvJTm+bTtKDz+ERqP88EFz5fzZoxw+F7gN939+fn18yLyZQDz8wtvQhoajUaj0Wg0Go1Go9FovIm8GQ6HP8vpdAqAvw/8eeAn5uf/9UEBqDjLYJiHeUYNDAUKTsHIUqqYL0dyCZzkyFiqAC90mbAYSGk6FavNN5Q6IgaM5iSt2q6d7M9dCFolh5sibAtEqXK3PJ/vruSiFK9aPpF63mSBda53e4JAQhkJqCuRQKdK1MwqFIoLixAgw9pHJgrJA8tyQIowWn0UF9bZeSlv6zVgJCIB2cvEQlUoUnyW32FsZM2L5ZMUnwh8O0UyhjExMsjEaMZJVlTqHauoSp4ljttS8yaI0KuQ/TTvkgpdELIrgxkqQhAhiVJmqWWkbjtLkJo+gGyOSN3WzaK+IJBEMGo49W9IHmeppxBFybPgEaBXoVPh/2fv3WMtW/LCvO/3q6q11t7n0d333rkzw3MYi8eYUQwOkIAVwAJbWLFNnAQUR4p4SaM8MEkcgkOQk8iSJechObYExmM8TAi2CYkS7ITADBABRgECsQfGMDHMAIKBed9Hn8fee62q+uWPqrX3PqdPd5++3X3v7Tv1tVpn77VqVdWqVVWnu1bVVwceVGCVHOcpk8y2EkRX8+JlvtddfuY8qgnrHOlFQZSgyoEXFq7kR7PRKRyHxEG3ofcTg0sELfEEPMECHR6HbvNVpJFSRZuOKQcCysZ6gg7EvAFxJT8EIhucBDKJIEOtswlHFUiiKIrHk+nprMPhiVIkp6quPG8JeOlRFLNMkglHwNPjraSHUONSHIoT2Y5TRjNOYqJXZZ2EKUtpA7UNJTOclPo51/XlYsXi8BzfTWiILBcrBpdQCWUMWgzvUxEduiLI7H1EXSYlV+uD4SRv64lKEQdOWQmaUSkCSm8Oowj1Ntk4mUoe53prlPrgRFhQyiKIceP4Ns4njvo1S5/xo9uGo14zf+/EsTLBm8fhcRoQK2LOTpalHVkk59IvncmahXV0OHrrWRAYVHECvsodNURUM06MzsFQH0VGOE9wmooMVZGaj9puMJ4bE0E8TjK+m3D9RJ4M5xNOjCBGp1XKCpxMpS/oXXlOhhFcJDhYuoxIWUFYpJ6w8FPp+8SYDKaci1RVpqrcLHkRLYLHWa+qgOYlAOd6Ukf0lSClH/VSxKmlb3DblY2htvtoRZ0YxAgiBHEMTqoUt9SDwcHgEkOt0wVlsIGeQLIe8g3O9JSNnCI4is6ySkwxNlkZU8mLEyFoEbiuU+bFPHIi56zMcaonBOvIkjnMhzhRll4YfKTrR6Yp4CTjZNcnKlqEkSgBTyq9Bs6qkNgcniKTnGpf3VEkswHFMAb1hP0+sz5Hj1Y5J7iqNvbbWvKwb3IajcaTwYMa+a8Tfr//eOnvIHfS7uvkL19Ka3+tu176XmJ99Mz3fa+4X+oOCNdN/0Gf5b140jwA8//mrto1Qerv77gXdt6RYi+U9HVXiPqPqPrvC0TLZyn/xVXpMTJmE2brerVDdUnOp9xZdiVvnzh/L1//3t9A/91jsv1wTSMiusDrAWP8CE4Pq6y9Sq0lYZZRCWXnCkreVH35d3gu/06P6YW9e3d1h4s1j4aH+TfBXBb3q5/Cnc/l3uk+1hkOIrIE/gTwv+4d/mvAnxCR36zn/trjzEOj0Wg0Go1Go9FoNBqNl5/HOsPBzM6Bpy8d+wRl14pGo9FoNBqNRqPRaDQar1Ferm0xG41Go9FoNBqNxkviQafNXyf8fpirprc/upQucre0XnoeHowHLZtXIv2HCf9qx7j7s7a95RRz2P2f9VtdgmB2KZ5t8BJHunKpQiLnkyuOC8E/w7c9+3X81b/wTt7x/V/Pt77/hy8svbB8wlivTfnF7XVX3cf1SHfew0PxKOrK/eKwu3y+O0/EgINQ1hvHXPdEVcPrfE5QKw86Rsc0BVIu616TCaJlLVjKipmQTFGBYx+AAECnUtdYl7ishk+5+BnmNbpG8TRgZZ25SCZZyci89lzq+vOjYBwFWCch6MALY+Cj6RyH4gV6zTVsWUvscExERpnASnMTke367nUqroKAsiES8By5wJQzZoah+LpW2xAWsSPVCnzonuU8P8/z+jEGO8Cbx+NLuUnxMTiBoEZQY52EMQvrLCTLLJ1yGEq5THVpXbZ57bkQzZGteDDMlIlSZoP6kmcRRCBmwSmo1JXfWuIJWuIac3mOQRWxsh6/0xI2WamqJS5Bcqm8Uo/1WspKpTzPKe97GuqzlZqX7XFBpXgeUl03ncVt0ww173PelLqOXDOLMNJ1I4OL2/hDXbstCEv1DE4YnDDl4jtIWUgm9OIIorjsihdAAo5Q3AziSDrRyZJsicEOytp5AVebq+DorKO3AYcnWIc3x6RjWdsukJgQlN4WKIqIY7RznIRyLYFcVrXhzeGqAaTUxXLv0ZQx5+pegF6NzhmDc5xreU5HvrTFoMaBT/TdRFiucd2E9hN9v6F3ia6GD5pQTYjLqGS8GJ2PhH4EoHeRmEu44gSBwQm9MwZXPQVqdYVdWb8epLgniucBxmS1XSsLp3QKRy4QrOfAZ4blGtXEQb9mUKN3pR6l2tZCKUIGJxiOKZbyFYSVHRFlg5FZ2hGDLbdlt1BHzAsW4hlUmdJAEMfSF7/Igc8MizV+uaYf1ix95FbncHX94dIJThyf2JTyP/DGcYiMSTjySrHBQOfgeLEiHK5wyzWyCXT9uC2boOAVksG6OmeWUtbPCVJ8Nj5yFCaOgqdTQ3FMBof9hpgdXg0nitR2M1hxiXiUpZOte6IUtaDiCFmJ0Ti3I051wSRndKp7rhNHyI5erfaVFGeDArl4XLyWcu9ScSY4AZ+EYxk4DonjbsOgS/o8bPv9Q3qCKGoLgnnIMMo5UTdM9aEKilfDa2LhlSPvGRwceePAOQxYWmDJDYIKq7xkIoPB077nVqe8YWHcWp6xvHlCHAPHz50Xn4v3rLMnZiOg9OoI1VWzmd0zUvqP2RMyVT9J8coIQ3Xk9I5tXZ4ZszFlI2RhY8Vt46TU/tG6PZ9Fo9FoNBqNxquPJ2LAodFoNBqNRqPRaDQajR0PM7sABM+Nxefx2Xwh7/qWn+Xgzy9533/1Po7/8jFjfMcDxFVfQCOX5Kn5gfLzWqW9Gmk0Go1Go/HEIyLvEJGPisg/u+Lct4uIicgz9buIyN8UkfeLyK+KyB99+XPcaDQajcZrnzbg0Gg0Go1G47XAO4GvuXxQRD6dsivW7+4d/lPAZ9e/bwP+1suQv0aj0XgCeFK2Wy5bSpb/zu7/lb2/lxHAUeYieL56+c387Jc/zU9967v59h/60xx9xfN8wU/8NGP8MNebmTBv8QmQr9gadj8/ryT32r7y8eetDTg0Go1Go9F44jGznwWeu+LUXwe+g4v/evxa4Aes8AvATRF548uQzUaj0Wg0Pql4IhwOIrDwERXjNLoq33IkMolEFiMb5OQwE7QKHKesxDHgxkCKu1sV4GbYiQu7Ki+cxV4pQ0oeM8GMrcArVSldNCsrckwRjCkXMeAqKZsYMBOOfKJTI5nQqSOZ8uFkTEQm60gmeMqITzJDEQKeFRsymWQlPVfvBYpA7cAFcgKHsHTKObBOiUjCoVXwJ7gaX8Z4yt5A5xaMtiLQ0zOQyTjctkyyFclmuUchZYi55GGogjij5GfKJd9zuXUqNa9FjhatiBiDFElkpo4lSgmTKMI4ALMiegy6G/2axwq9CEGLQC1IEYFKlaxZTQeox6F3RSbYqzCqIBRxWxBhklJ+ololmUKoYr0irhTUSr0aXHnuTsvfWWqpCIMzOpcIPhJ8ZOEnulliKALGVhJX/tT7EiGLofXZKEXA56wII51UaSRavuPJpK0QzuFxFu5oG2qK1RLeSSV1K6BU05oa5Tu6DafIVoboKXJAKGUxOCGb4kU4CspRgIXPte3VZybCYcj0munU6FxGJKMuIS6hLuG7IgwcnDGo0utU0naZvhvpXWIII64fSdFtn+dcJ2ecgIjt6ocIg3UYxsK5rWBwbtNkGFRZ+rn+KiF2LHyRVqKG7ramhAAAIABJREFUc5nOZQZn9VrZ1nEootAxWxESImQzvHkQyJYIdPTWlbYrSlDlmFCehpQ1fNHK3QxVeqkugxoaEl4zvRqDsyJf9HBkQrLSxy185MBHVt5xs/Nb2epxMA4X57hhg/alPF03ETRtRbRBhVDzceDhyGfWSQk1DjPhwE8c+Z6FS6yTIgZOM52LNV+lDQJ0eLCBgMcrLFwRhU5ZijS0tv9F8vQ24LVHpAhyRQyvufQHs3V3fq4KR0EYEzW90pZ9lbs6KZLMTpXOlfvzIgTz+Npeeq2/E0zwtR0E6Uubklnqq1W4mTnwxvOya9dH9XdBV+v9wsEmeV6YijD1DQvlZmc8O0wcDCv8okhRDw/OuBkiB96zSkXqGWqf5ao00uW5r6ltXsvvp/No23t1Iix96Vc7LW0r7f3eUdm2YMgwUWS2AN7Kc2vcHRH5s8Dvm9mvyPyLp/CpwO/tff9gPfahK+J4G2UWRKPRaDQajQfkiRhwaDQajUaj0XgQRGQJfBfwJ686fcWxK4dvzOztwNtrnG2Ip9F44pmb/0tpzpevfalxPUweHgf7+Xk58rSfnuPiNpkXX04Uygsy0QVPLT6HwMBb7fP5FXkPHz//NYwEZIRQPtdtMXdLHDKCI/hn+MPdH+eLD57ie37wRzj7sR/lT/3tr+b/+Yn3kPL31tRdja++6JIOs3GXO+nAMogHcv2sYFJ/5ktpa03f110IA2YTu1dsL2cd2E/rOksp9p/FVc/lerQBh0aj0Wg0Gq9F/hDwWcA8u+HTgH8iIl9CmdHw6XthPw34g5c9h41Go9FovMZpAw6NRqPRaDRec5jZe4Fn5+8i8jvAF5nZx0XkHwHfKiI/BPxLwItmdsdyisYrzd3eAu+/mbvuG7fLb/PsmvHIXth7pXWv8w+S36vyeZ1z98rT3e791fJ2/VFzv3t7NPdd3linK8/cP41XU9nfrZ5c55rrnrt87PLWkdzlXLlWxDGEN/D57sv5ooMb/N3nfpif5jdIeY0x1csyxqbOLLgcJ4gu+Ph/JPzkTxrf8Zu/w8G/msi2Af6P+rNsYWkXBItWZyPs5c7Gcs720qnLvLHE3WYuGHXWhaUryuNxc1Va10n/bs/swWjSyEaj0Wg0Gk88IvIPgJ8HPldEPigi33KP4P8n8FvA+4G/A/z7L0MWG41Go9H4pOOJmOEgWBXPJXrniFk58J5BPNESGya0DkapZg58RMS2kjFLDsslgGL0Dg59GaUZXBGJnUXlExulyw4RUE1ltY0ah96YTNikIhojXxwBnEWVCkzRs8mOhc8c+TKSFTTw/Bg4oCNeMToUVDhUj4gQkmIYnRbZ260uMbiMmTCZENTx4VURoN3qhTAp66xMVu+v5kNF6C2gJjwth+R0i0/ICUbGyCTiVmo3piKtNIqcLRlEE8YMU85kc2WscE9klue05vu2MlaXbDeumCkitIThtQj4VGAyI1AkkNEuygHL2GJ97lKEkXppwDXXUUStYrZkhpls44n1p5ddXLPQUqiCSpk3qRFUrAxMitBpkU7GvTyl+tlpkdhZLevtz718ZYxExsyI2YhVdlnyWMrTmMWjViSOEmrdVASH7ss8yUSJ2+96aYxw/h4lYWRyfb4qRZ5X5JNlpFWqpFJNL8Q/y0OzGZMZzoqkrndwKMozg/HsELkRIlNWBucIInQOBpc58IkgRZBqpqRNR06OPHnGdY9ZETp62duURzOqmaAZ50r+4hg4j4GUlTFVsaXMMlcjZSVRZKZOhIV4omUGLc/NCUVgWCWuoQphB2fls3Xb0ktj4HzTMyatwtgiQTQrIj+pOd2K+xBSLcfERLaJJUtep0ucCJ1WQSLKSYo4k63INRv0NeFp8qRVx7TqWSdHMimS1ipr7dS42QnnsXwfk2OqMtdZbrp0GREjJ4esO9KmYzwfmLKrcUmt87AMxnGXGdR4blQMmKbAetMzZS2SSc3bgfm57GdhrZeiIN2WB7YV2qoJ60TtJ/alr0VNapbZZCMmxyr6bTvYZKFLpc4FKQLKuazjtg1XkebeC4pUyyNWyW5JpaQ6mTGRGYkk4rbO7zOXy+Bs27c4MQ58qT/Rys+lM86TkFGcwFEwDnxm0Lz9fZKnIhVOte/Ptrv/qX4pfdfuPHv9ZbIivzQr/eOY5n5i93d+JtNeB7l/V9GMWJS5d9zrJytm9ufvc/5Ne58N+A8ed54aD8vd3qg9yKyGOezDvuG7as3+dde9X56lcK+3vw/7Zv5yn+C4822vXHHu8jvIfMWxq47P3+8W/jqUawW5sOZ+x4O+Wb3uzI+XEsb2PsUrzj+K9B+0X3/Y9K5T9x4kzfu1NYeIqzMHLred+dzsTCj6dZGelEfea/8X730ebvWfxfOb38bpQMqU2Q0ylbDzlVXILqKIeKb4MZ76655nh9/nrfYWfjv/HCnfZueR2KVXPs3/zk/MngnBo3pAyrdRXYJlRDwiilneyqpz3jkfZq+DMdWf8T7l91LZrzf3aotXtdnL/cB+mHuh1wrbZjg0Go1Go9FoNBqNRqPReOS0AYdGo9FoNBqNRqPRaDQaj5wnYklFo9FoNBqNxpPB3aYvv1RJ2MNM/34lmacmXyXVe7h4BQeiVb6W6zZ2++uw5nQvb+d2nanql6cG328pBZfO73M57N2WU1y+/qq8Xl7GcLd0Loe/aqnD5WPG1c/pbs/u8vF0l+MPQrpUMg+7beTlrRb3uZc0cz5+vyUPDyPevFwv4eLylkfdlh9lf3S/668Tb8IsoXpEzqeXwqfarvfJdP4GnxW+mETkMB9xnBeswufxfnkvq/Q8ed4Gs25JmfIKlR4R5Ztu/Tk+53jk3/uGH+It//WX8Hvnv8BH+FVSfvFCupc/X7yL+Vgk5VNEwi7v24B3qbN3FMfj6q8vluO9uVubvbMcrh/P3e+pzXBoNBqNRqPRaDQajUaj8ch5ImY4lDFyY/CRwUWSKevkeF0XyBsjm6GA9xHvI88uzklZiaaIltEW0SJHEzEOvHGri8QqaVv6RKeeQ+9J5nB1gCpl5dBnghpTFlZJURHOIvSaUU2kKuA7j0Y0SKYkE26GiaNQhCFFTBa44TvOUyKIkKuYL1VR2YEv+rNBO6IVcdxRMA59ptOMihFNcGJ1G54iP8smnEwOcrcrr5p/hzBIz6cvAwYcbwIvxpEX5JxZBacyy+AKKrtx3TEXieA6GeskuzFfKyKzIrWDTbatLHIyY7JEIjPlTFJhshL/OpUR9SJhLOLIZCWeKZdrUxVVziSzbT4yxmQ7HYwAkyVOY3nf0U9FfLlKmWTlfLbi+Exm1KpAtnInMQtxjrsOUHopEskpl2uLrK/kzwusk3ASPeupw0w4nzrWqUiOEsYkETNjY54u78sZS5ltLLOxhCJMVW6X60iuiJaRUyYSgcRElEhkQ7ZEloyjSB8VJUoR5EkdN9zIqpbZRCYhsiQRiXOcNqGiTIxMlshkVrrCm8fXOH1WvAixSjh7D0ch83Q/MrjEOjkOvWfdzdI/Y+mKTnGMnvWmY1z12zb34u3jrVhvrpdmRVaYkkeBzRiI65646Vgnh5nw/GbACzgV/Nweqzj1NEpNu8g9vQpLX5730htjKsJFJ0V8mA02aRfHerUoz27sWWdhzOWZpypnFCsSxDFZrc8Zo0gJo0SSTUTbgMDCOYIWiWXvQCKc1LR8VRrO0tFkwma1IK4GNuseBURsey5mWHij11LPxiyss7JOspUILhwch8Q0BaaTJWnVkcbAye0jzqInZtmOIqe9+p6qhDFa5rmzIwDOYmDKwjo5zpMwOON87PjoaskLk2PMpT/IdcR6IyNqwiqWtzpBYZ3mvs+27TFJqZNW31a9uDrgLCpTLmHWSelrn7rtsyhxRRPWybDa7qX2EWdpYp0Dz28G1jmxkg2dhaJYzcJEZsPEWtas5JxoG5JNpLzBbENMa16YHCJW5aBFeLnO5T6Wvv4O0XI+oyyc4BU6NZwUcfDpasnq+SPMlNunhzw3+irOzGwsoyZEy4S9th9UAasCziKfnax0iiqQc5VwbkuiCjSrLHKyXTnMwtxo9ljejTQeFQ8rOnwp170aa8Td3po/fLxGvHDLd8r7Lqf7IFK8e70Vv+rzvY49quvula/rhH+Q2QuvFh62Tj9oeT1Iui9Fsni/tF7u5/Eo8/7S4s355D4hHEfDm/mWW3+St33hr/DBjws//nufzg/c/kVeWP/WdjbDLIUUHKqzdLzfihx/6ORnWD3/HH/xL58A7+LhZctXzcKA69/7q6G/ftgZRA9Gm+HQaDQajUaj0Wg0Go1G45HzRMxwaDQajUaj0Xh18/K+MXo4Xo3Oh5fC3dwM+1u1pSvC2aVjl9fjX+VTuK4DYv+6++X7clr3Yt8tcTePRIlP6hZ/Rtr6LS5uOVlDigO7x7Z3dTu/+1K3Arxr2DmerXdjl/act7uFu57X4EHr87wF4r1mFTzONjL7Gi47QO5Wxy6+H56f5e6Z3m92xCvZ3u+sp4JHpCfbOZfzJXiCf4YxfhjInG3+gL/54Xfy3e9e4vR3OA6fwpRXfPXw9fx8/scc6NMccpNzOWGyNY6AkVlwzM18ixss+bB+ggN/wC9PPwgIIj2df4rN9KE70r86/3fmscyqmu/t/u/vL7a/xz2bZbe15467bV35sLM9Lve1dw/VaDQajUaj0Wg0Go1Go/FIeSJmOMzjQZ1LdK6MnqQsPNV3nETPlPJ2ffhyseLmsCJmx5jKmt2cFNWMc4nDbuTAZ5Yus0ZZ+sRxmBCgcx4Xy1rs4CPLbsPT/YZ1csWVEB3gSdWl4DQTNOHEqmtAySZ0mjHZjSA5zSjzetxENI+KkSl+h6DQaVlLrFLubeEg1Huax40UGFzmRsiscxkPVgEV2XoNnMBoxd8QVDnyjjcsMmaCEyWvAmfJk+hY0NGLMjhh4WHpjIXLjFnYpN2IV/EssHVbZMqa4ylDrO6DZOV+Yh3djiQg7K0jBxFhNkE4EUTK2nejrJ+fcnVD1HXKAjizrRdiZqLen+h2fDiasUmCq0NoAnXtf8m0SnESzMxuh8mMKduFsbmUhakGngfrzcDXApiyMEaP14TTjJOSfqqjhmW9dWaq3oh55L6so88kEuDIssuQkYm2IZNINjGxJjEx2jmRDY6w9QaYKJmMViNvlrx1NJTyWe/iJDLJhtHOMTIYOAIrWaEoiQhSnptiRHNQ34Ykg6AwqDG4xEGY6DVx1nnGLCQTBpfpXGLKSqiOlBw9ZoKIbR0FQYxe6yp1yajLDP2agzDiXboQFqB3CV/9DSKlzo1Zt+v+vZQTG8v0Do68sfCZQTPrrEzm6nOfvSRGJnMSiyMiJyXVdfbZyl8n5c2CYqiUuqSp1J3Jil3D9kaGe0LpK0ToXPVFuFIvtdYDJ0rQ4gZwYuQspKmUTwbMdmv2AUIN102utomdr6RzwqcuE68bNnhfn330kLW6CfK2rOb4MsUNAVo9JcaUlOAyTorLIFnxRZjBmPy2nFP1mLhqfDEyiVxdNeD22tPOsS7o3jj2JmdSnvsmIVEcCVKdGfvumPk51OaPq516zBAxVlFrOy1pCLt+r9T38oyzlHqebWIeyRcp9x/UiNlwWtIJAuKMI5+2/ZuIsRYhaHGPlNKr/UNWNuuBnJWYSx1LNpd5EccYxfuxpX5MUnI8u2uK2UHIZrjqOZkdD7NTJhuIlXaQREq9p/SlU861FBqNRqPRaDRevTwRAw6NRqPRaDQar26epCUKT1Je78Xd5H2Xt3y7KtzlY/eSOz4qSeBV8V83zruJMO+Me1+iOX++Uld5pfjuJWTtfuGuKL79tO0e4R5NBi5znSntj7ON3Es4eFW6F8M/eDG9ku39zrSNiNm+6NXh3TEpnyEEsk3cXLyV/+0L3syX/Rs/znt/9Cv4pl+8ya+v383Hpl9FcPy4vQ9Qbkuoy4bS9mchb5fsXCw/w2zNZvqDh8r/xXP3r08v7xO42zKbx7GU43pb4rYlFY1Go9FoNBqNRqPRaDQeOW2GQ6PRaDQajUaj0Wg0XibmJYI9txafyzq9SNA38lc+7cv4ijd9gLf8lY/xfd/wOr7mO59hM/3k3nVFlwlWxKMAonWRpRaho8Uyo0BALL+i8zsahTbDodFoNBqNRqPRaDQajcYj54mZ4ZDrhiJOMhmhc4lBDS9CL46gRfalLrPsNozJ46TI2VQM5xLOJXo/0WneShuzCU4yTjOdQu92csTgEl4zXY0jmXCmRlDBa0Y1413G6W7sLGhi8JGU6zVZi7BRS7xBipAvm2xHe5zAga+CPmeMWRic0bm8zatswxpejbAnm5tyJmMEUZyUe5gFfUdBeKqLRINN9tweFZ/KKGAQpVPlIMCBN45D5maIrFO59jQqg5YwC1fyZ8AmlXIbXJVcmtCpq8I3x8YyS+voVem03KdXwShCzoEi0gsK6wSdFmHlygkbgWQlfRVh0CLsy+a2ZZzqvQ6q+FzkmIsqvlSBI1/kcgtXhG4qsN6TYIb6LKpOkrGaLWeJZe9AYhVFqrD0pZwHB0tv9GoEl1gMa47WGw58ZlBlyJ5sHUvpUIRehYVTVEp6RXoXkCSoCMk6NjKQZCJXs1yyCZOM4jAyKg5nAUFxElAUZ/UnvmjyLINAYkLFYTlXSd7V66m0/nF4BN2mrZR8zfWqiBTZCgkPwojr5nweMGXh2cWKwUXWyRM003cT/eE5VkWBy8WKW/2ag9VA55Sljww3T/GLNYuDc270a7puxA0bumXgRhgBWISJmx3cntgufPNalIG9g0GFaLBUx6GH1y9GbnYjB37i9tgDA1MWghqKceA9IXYsXSYnpR82HPZrjnxmHZSutuFkhhPwWupfEIebhDFnXBY2dsiJLFlzG0UItb4MDg69MRmYeTbZ2GTPwjkWTop000e8j3QHKw6i43XDaivXXCclmfBUVwS2q6j0LnPkEzELS68cAK8fRp5ZnLMY1oSjcwAsKodHp9zq19weO8YsLL2r0s+LctpBPZ1PHPUrjjc9Z9HX80VW6KsEt1Ojc4ImCKqQYWkLFgRudLLtD5LBwhXxpAFOOtJ0zG09xOuCQRWnxs0ucug9huepbsPgEmfRAUqucYXaIZ5FoctKp6VcJyecxMBBFfwe+YFpWtKJw4swOGXKxjp7BusIueNUPKOeM+oZZhmvC7zAU93ImfqaFzgMCTM48EWiOfe1s7DTKOcOfOIoTDjNW2HnEEZ6tfJ7Q6soVMp1XoRoRT4698VOYOG03qfb3m+20lf4er+zQNOlkv4s7HUZXHLb80GEKXZNG9loNBqNh+SqbTPvt5Xmg24D7FBdlivyqroWlGeXX8A73/KpfNU3/AjyGTf57v9E+NKf+QCrL/19hP9vbyvJK1wKNgKC2aYemf9ndbctIBuvFG2GQ6PRaDQajUaj0Wg0Go1HThtwaDQajUaj0Wg0Go1Go/HIeWKWVDQajUaj0Wg0Gndyv+nfjcZ1eSXr0v4SuZczD1dumvoA110uszu/e3fMQfdGPkM+n1t2zB+5MfDfffvfQT/3A/ynb/sX+df+4uuZ4osY/yOC2wkhbboinbJcQiSw/+78zm0xZW9JRkZlSbaza9zXdXA8nm0mX5u0GQ6NRqPRaDQajUaj0Wg0HjlPxAwHL8atfsVhv6HzkSk5gnZ0DjoVBnMceWNx4xQ5OWAxrJFNj4oR+hHXj6RYbnXZbbgRIp1mogkHPrIIs/SuxHfkjaPjE2JyLP2EE6N3Ea+ZMStnUbg1rDi+eZuz8yVP90fcCB3PDpHX33qO5fkBY/SMybOJvkgu1ehUWDrHgVeOq+DOaeZG6FinIm1bOGMw48AXYdwzwxooErMiMisSynM1FJjM8fzoCFkZVHh2KJK5VCWLb1hk3rg4Z8yOmIVV8rwYB1x23AyBp3rh05aRGyHyVL/hIIycjh3LsWfMPSk7egefskx0akxZWCVlTHCrz0xZuNkJmyQkg9PJs05FVHfghYNaw5xANMVLEdk5gV6NdRYWzrgREp3zrJNwe3JbYeGBh2jCyaQkMwRhzFWA54RsytKXcjsKCSew7oQxC8chF5ElFAGcyVYjI1LK7zyVsMKcL2Nwxlmc5W/GYTBSFcstXeaNy3OevvECRzdOMBOefe5pPrzqSeYJWbkZStnP9+/FcFpkeMPkOI1FJBmikrPhxROliOgymY2s6awjkwn1J0Cfh6J7NEFRpG4AlDEmiaxkQE3x2qOm9Aws8oKNbNjIgkymZ+AgHzBQxJbeHJnMAUU+N2gR8amwfVblZ+JoWDF0IxnhxakD4HXLU0QMP3Z0zrNYntMdn27b7uHtQw4/saFzuYgVw0h3fIpbjPSLNX2Y8C7hFiNdWrEMI8Flej8RtDwrpzC4zIGPmAlH3nMWhCnDYI6n+8Szw5o3HN5mCBPD2eFWhji4hAIfWXv6VWDhEj5EwrDhYFhzGCY2WXCyL341xqT4KiUUUVZRcEmY0oJTucnk1xxJKIJWV67pXMabcBAEiaWtL71wFODIJ270aw5unNA//SLiEjcX50xZ6VzYpn2rX7OJnpPoWLrMrX6DASfR4cQ4DBM3F+ccHJ0RbpyCGmRh8cIRR/2ag9WS86SMrohTu22dzgxO6VW5uTjjxvFtNjGwTp51cnTasfSZo2HNrannqbGcO1PorcgzU+o5cp5nhyKV7GsfWvomMBMGJxgdt+PrOPWf4GanHA0rDsMhB2EAlGeGFQdhJJtwEj23p9JJDJpRgfMYyKY81Zd+MOXSJzwzrHh6cc6zww2gY3BCp0JXZbbn0bFOnkX09DmQNRP9ho0ogzvm6T7y1LCinzqe6Xsy8CmL0r92mpC9F0sqhtUq8bq+9NW3hhW3jm4zHJ2hIXJjNXCrH7m5cYy5SD+dCMmUIEVqahhBBJEixTzw5ZmskmzlxHOdCwKdK209m7BOQswwVUHwJgmhXuOqcHcyvxW9NhqffOy/RW2zGxqPileyLj1J9djKFpRE7sy3AYLgUD3gK4ev5we/7ud45s99iPGffIj/+11fybf9Mxi+PWN8DPhu9md32F3LYT5eZhbM0sjd2X1p5H74evSRzW7Y5aFxPdoMh0aj0Wg0Go1Go9FoNBqPnCdihkOj0Wg0Go1Go7Hj3mvG57esdw93r7X619kScI7/cl5eCvvx3O9eruMYuBzf3djfOvClvoOc544+PMLFNfcX8/co3/7PW63f6y3141yj7yj3dbfnfJn7le+98insyvFBy3DOi9Y0Lta9MrvhqvDFpwAgovzs+CN8yg+cID/gUO140zDypf2b+IP8Oby4et82NgDVIxbhWc42H6jXd2AZpPyXVaUn24bOP8UYnyO4m4goZmVLeACzjNMyE9drT7ZMtonV+Ls1rbJFZ84nD1ge+/e534/MZXS30FLv0Godv1xuj5LyvC+2pYfh8taiF+OeP5efd9+GtM1waDQajUaj0Wg0Go1Go/HIaTMcGo1Go9FoNBpPMFetIb/X8avO3Su+u51/VG/d75Wvy2k9yO4B9wuf7vL5QXk0MwHuzOnjmmFwnXgf5xr9q+K+1/N9mLzYQ1x/0Zlw3Xbh9AY5n/Fli3+Hv/SWM24MK/7qe97Iu8//Ljmd8f6zH+X9F3QKu9kkOZ9wttnNPCieBsDKrIBkxb20mf4AgDF+5C55vhfpIWY3XE7jchldL/Tjozzvx5dOuvJ+7MK3O3kiBhxEjLAn04rJMSZHsjJFw4vQ1dlRMTpW64FNDKSsoJmcHHlyyJ4YbhZxqRjrWMRpySDVIGZCzsomeTbJVYmYkA10b7ZTNiFl3YrtnEtkE87HjjF5zqYiX5vFatGMvPc8FNhkOIkl0uShc7upJ15yERyaQlZMjE7zdqJZp0qnVagoJW+uShlV9uLRjBPoFJwIHqF3MLgqtOtGjrs1To3OJTrNBAGREmbhMkHLVjRjNrwKQQznyjGhlN06CaQq+5NdWfXOIEmRo+n8XCEIVWiXUDxODC9CgiouLNLCtQqai3xtfkZSw3QKgzOGKsibsttNcBLIVqRs2cCMbRyZ8n2Wt82Swl4zye0m/zixUq5iBM10LuFcQn3EVylh0Fr2IgQVUjXOaS1DqfkVuVh/tOZUbS6U8tnhcfX4/KezcEEUOV+fMbw5fG3OHR2C4s3jcAQ6IhEH9ZjikVnnU35K0VDOwkiAaLBKwmlUTqaOW1PAa8JMiFnxWtpkzI5kSsqCuoyoIS4hPtMt1yRTplwidWqIz6AZF4oAdooei0pOiiG4WuezlTyQSztTAJmfsTCmUg8NGLMSs+N8o7VvqO0p6/ZXwEQkWZlil6ZAzlLrqW3bvMztnCsmkUkp+/JsQqmnBptUnvuYlGgQ9y6c2/pUy0xdRkLELYo0EYrYMmjCa+bm4pznzw/odddJRCuCzAnhLHqm5BCpidRy1VCEmlu5rJW0B2d42dXFaIaI4XxCxBiT4yz60h5M6FwkaDk3tx3Y/Qop7c22ZaZSpgjO5X0VwUVS1m1cnUt0LqFS5JxjErzaTj5JiXPKspW9quyez7adiWz7mLlPmM/NGXYScNLjJNBpxkmuckcr7UEzq+hL/RIjWhHFTlmZTMgmjFnpTMk1fVFDXcb5WVpV0ipts046rX1v2j3GOsnRLnzOyIXfB/uUql/OT7m0hU0NHBA2CdY5ke0uETQajUaj0Wi8CmhLKhqNRqPRaDQajUaj0Wg8cp6IGQ6NRqPRaDQajcZFLs+uepgZP/txPY6ZQ1eJHNsMpVeG64g3X+vsSzH3xYdXif/uV1azBFNRGfjMxZfxX3zms/zmycD3/vOO98rH+eDqnezEk/vbV9aprNcSsV4Up5ZtOS8vZWht69VIm+HQaDQajUaj0Wg0Go1G45HzWGc4iMhN4PuAt1KGmr4Z+OfA/wS8Cfgd4OvN7Pl7xgO4umZ5dilAWV88j4kFMTREnGbG5FlNZa02uayUNVNEDe8STsry+t43AAAgAElEQVTGHUF2a5Ftjm9/za0YWs/nuq47mVR3gF0476Ws/XeujLStYqhuCM9U12CP2RhzZsxKysqUy1rzVRKe25Rz685xs4PBCZ0J0ZQgxQsRs27XFqcs9D5tnQhj3q29F8BrWUu+zsILY4+KsclSPQa7rUycQNBMr4ng8nZd+XaTpOpR6Gc/ghhajwed175nYnZ1/fTu2lTLcy7bsg57t6559ii4/eewXcNdzst8TV3DHOr3qX6OBpNju/5bBGIuZaqyG0/LVp7R/LDXdUD0NJbrStkJitG7snZ8rOvjN2kXTzLh1uQZx440hu16/8vkupa/3GtZH271/i6PHzs81C1yMhmPJ1TXwIw3R0/Yfo8kFEHRbSPe1PHD+VpB8ShmblsW5ZjbbtGjd7wdqveZyzr6dRLOonI6Bc7HjuAS6+g5i55OM6spsEmek6ljTI7NuietO7SbcDohYqRc1sFvaplLdT+oy+SsrDc9eQzkyW/XyasU94BK8XaE6hZRDKfGlI3zlOlMOYvKJzY9R6F4EdbJs6l+BtCSB4NJplLGWYnRkXM556urYKKM0RfXy+x4KY6Q5KTWv+LGoHo5YoYk4HOp+6tUws1ekCmXuFdROZs64qaDrIiUe59y8cPMXoPeT8XBkAVxpRyU0r6nDLfHwCYGzBRMsCyIKz6M2VGjXHxP19V26vacLnMZqxi9ZgZnLF1m6Dcsw8TS5eoskeI9qXWleBMyXqzGa1sfTso7t0Iwj9NA0JJW51Lpp3SXvpPibdhkwalt+wLYc0dYKc/5u5O8vQ+nxZ3SKYy5fE4GQYSeQKBDxaNSW4qUjZvManpW2vs6uQu/B0wz66ScTIoZDM4jwM3ObX/3iEuoS6XPr3nQWie8FT9ONqovYlePFt4IaqgonRrJyu8zr+V4V9tGSaeEmfuisbpMzEr/nhy4eK/t7hqNTwb232I+THt4Od54X1at3S+/l2dEvJT8vRz39STOFnjS8vs42J8ZYFccu7wl5nXiytsZB//z7y74Y6/LfDSf8aHxVzDbF09e3qLzbp8vYxd+Xtxe8qoZRI1XC497hsPfAH7czD4P+CPA+4D/DPgpM/ts4Kfq90aj0Wg0Go1Go9FoNBqvIR7bDAcROQa+HPhGACv7mowi8rXAV9Zg/wPw08Bfelz5aDQajUaj0Wi81nmYt9avxBvv+6V53be+D5PGo6DNFnjtYtx9dkPZ6wzxOF1w0L2RP7v44/yXX/5LLA9/l//4f/8svut33oHZhouzDq6affAoZsk8ivbSeFw8zhkObwY+Bny/iPxTEfk+ETkAXm9mHwKoP5+96mIReZuI/LKI/PLtuH6M2Ww0Go1Go9FoNBqNRqPxqHmcAw4e+KPA3zKzLwTOeIDlE2b2djP7IjP7omM/PK48NhqNRqPRaDQajUaj0XgMPE5p5AeBD5rZL9bv/wtlwOEjIvJGM/uQiLwR+Oj9IhIxgi9CSK+piB81V2FYkXItfCIcneNPljjNW5kjmiEr6iOixtBviiDMhOASXjNLP7GKnl4NL1Ikhr5MIVKKHLKIC5VNFmIGrwmRjPdF9uYVDsPEsFgznI70Lta8g8uKq0KxeTOYIsXLjFXmF804TRE3FRFgkHLNJrlyPiubXOR9J1GZqtDwZFJuT5nTmDjyniDGtFUCwjoJJ9FtBY9eDCeCIATdk7QhWyEZFGmZiCEIXqHTjNNMBlZJESvHkglSywwrYedRLFclklY/mxkiFzU0RpE5dpprXnZTrWbZ2iylK/kqP7MVYWSycs3+yNlksEllslcRWRY5HbPkkhJnruFyTWus0rtU05tyST9WqeRc5lDqQqrSwTmvUqWTl5mPzeK7XD9PlolkJkayZDKZRCST2UiZ1ePNkyVjeIJ5co0rkVAUIVNUeEKUnTwnk8FgIjHKRCLW3GVG4raGFL1PJlmudUCLYLGW7ZThLAonk+d86ggu8/xm4LnR4cRxc71kk5XbUyiivZNDFp+4gYaE85EXP36LFzYLTqYijUxZSKseO11y/sIRL24GMsL69iHTqud07OhcImbHSRROpsxQJZ6xlveYlHUq7WVhjhdGjxA48gucGGNWXhx9kRVWGd8qwSgjAJt1j0jH7dWy5luIJhhFRJqsSPrWqYj6ZvlpMmOyzEbXRNuwzpk+zXLJ0n5OphKuVyGZFVEqJf5NVsZNR1p15LFINs+iL/0BxpQdXhNnU8dJdNwQGJNjnZTzCKeT8bHgeXEzMG46ptsHWCw1//z5Y26vF3xi0/Hc6Lg9zTJUJVtpn+skTGalH1v3jNHjNXMgRtCOwRW5LuzKYEzGacqYGae24cgcYxZMwdX6POWdZHXKMJlhGLlOw4zJEbNupbyrGHCSt6LXsygYyqTleZ1FWCfjPJYyTQarVIS2qymwTiWNTRK87KS0yXYi2sQsX8zEvGHSFafR8cJm4IWx42RSeoUXxp6TuJNGAgRVTuKuDDtXzp9NgXEKjKsey8LqrNT9KZdwRcALltn29ypXTx6dfweAYBR5p6uCUKdGykWUqlb64iTld9OMuyrSxhOAqz/vJ2BrNB6EJ1Ha+PgpWybG+we8g3mLx5ejTIvEu4gWX+5neL9tYO+XH2XoPoVvvvVn+O//xvcT33KDzTv+Id/x97+Wt3/se4Ffu0t8LyWtxtU8OW3/sc1wMLMPA78nIp9bD30V8OvAPwK+oR77BuAfPq48NBqNRqPRaDQajUaj0XhleKzbYgJ/Afh7ItIBvwV8E2WQ44dF5FuA3wW+7jHnodFoNBqNRuMVps1saDwOnow3nC83L212A7y87TS9gk/vQVIu87NVBrpwi1vhM/mlrz3h9V/96/z2j/y/vO6b3swLq1+ocX7P48lu4wqenLb/WAcczOw9wBddceqrHme6jUaj0Wg0Go1Go9FoNF5ZHvcMh0aj0Wg0Go1G41XAVQKUJ+ctYePVyFynnuR6tG9XAxGH2VSOyJI3L7+Sf/vpz+Abv/iX+NR/5VfQpz7CN/6Hb+Pv/4PfoKj6Lm9J2URDjYs8EQMOAvR+wruE95ExFdkZsJWG9Wq4fiQM48WLsxLHQI6esFjTdSMqxjo5nEt4KSLKgzDROXAKnTPUR4LfTceaTBmzcntSztOuIeUsWJUMdpoJw4a+G+mqdLJzRQLnqwBRRYo4sUrK5ms3Odd0jNNoeBUWvsjmOisSt5SV06jcHpWMMDjjLAqnMbK2RJ+r8K9KzKKBJTidXBHCUeWQlElcU4YxC2exVINUpYiTKVOVoe0rXlJWku3kkpPtZHGbGnbKtVzqdSU/RcY3mRAwohWZ5lSFcJtcRI255q/kBdBL94Jt82/YNu5ZFDeZQJUcjnkub/AiRfxYwwQp95734gVhk0r4sYpBU735mEu9SCY1DiVnR04Os/L8tVYJrWK3fbllFkHMdtJIK5LQbEYiESVitcTK50Qm482jVSo6ykiwQBZDTZhkwuHx5hhlQtGtcHK/4YxMTDISiShKFGXDCAaKbOV6pbitXlYkNHsx1TBCysLZFHh+VLzAC2NX8pdKfdmMHWcnhzifCGHi5PSQs+iJeVcn4vlAXHecnR5wNnX0LpInxzQF1skXOSTGeYSzlABX64nipNQfah2OVWy5TsJ5chz4SDJhstI2B1dkfHPZJxNicuSsrKMvQsakWBUrokUXlWq9m4p7E8OKqJCJKEXAma2UUaelxKYMcU6IIiAdXMnD0mX62mflsSNPjmSlPSVgnTySDSeZ81TEjNEo7dBKfTyJibPoeWHsWJ0viKcL8uQxE1anB7ww9tyeHKdRWKddXSv1sjzfQRWnmSl6xuQZXMSp0emiSGIlVyFvLuJD2bVnvaT8SXtlmrZ9AWyyXaiHTnMVV5bvU1aSzf+o2QkWd+W2a7tzu/JV5hqzK2LKbIQqXdwJI20r98zkbQ0W0SJMNWEVfe13im517sNUd/VT90ShM2bCZEqMnvXZEkuO9WZgTI5su7zO4sggRq6Ft30G2IUSLPdtIEUQGcToXMaLEedr53Cp9DFdKvUyKAxO6FUR2S+9T25E5B3AnwY+amZvrcf+W+DPACPwAeCbzOyFeu47gW+hzKH+NjN71yuS8Uaj0Wg0XsM8zm0xG41Go9FoNF4u3gl8zaVjPwG81cz+BeA3gO8EEJE/DPxbwOfXa75HRByNRqPRaDQeKU/EDIdGo9FoNBqNe2FmPysib7p07N17X38B+Dfr568FfsjMNsBvi8j7gS8Bfv5lyGrjFeNJnvbeeHXypNYpxyzIFAl86sGX8ab0Zt56tOCfnpzwAf01/lD+fP6bL3yef/lffxfve9cf4z//qS/h3T828cLq/WT7Hu5+709qmTQeF22GQ6PRaDQajU8Gvhn4sfr5U4Hf2zv3wXrsDkTkbSLyyyLyy485f41Go9FovOZoMxwajUaj0Wi8phGR7wIi8PfmQ1cEu/K1nJm9HXh7jae9unuiKE6iJz+NB+Fy1Va4w8q0f24m3+f75eP7ceql4y/tfaYg1au1n9bMoyxjV+O+V5zXfa774a53jeDrfe5vwTnnCa4u3/3rSzlJfdb33gJU9uLbz9subbPEB0//MR/kZ/i51e4Zfpz38JU/H+DnFafvQeV9pLy6793diV5IT/A4d0RMt7lzG1JBcNfY1nQu63t5jOZym8vyUdWhy8/5QV1KL0d/cZ08zeW3/xPuX4/3RanXu/cnYsBBNXN8eErXj2gVr63Hjk6N3gnOhAMfccfndGenHC7OsSo3RDPqEuojrpvohw29K5X7uNtw2I0cD+fouRHkmE6FQTPdYsNiuWIRpq3IcEyOVCWPTjOuiyyGNYfdyIE3bg0rFrduc7zu2YwdOZeK/sLqgMNwyMJ5BOEoCAd+ImhmysrCGUEEVcegStBZPmbcCCPeZaS2uzB5RPj/2XvXWMua9CDved+qWmvtvc85fZubr4xBQy4Gj5GJwYEYJ46DnSBMErBwfsQJthzL5AeKREAEgRIFKVIkiIkUEguTOAgbLBHLE4GIjSNsxcHYDgQcx8YGZ7DH34zn4q+7zzl7r0tVvflRtfc5fb5z+vJN99fdM/W0jvbea69VVatuu1Wr6ik6KSK6oA6VkgdOBJEiyduL2HKVMnauyBKLnExwezmjFeFeNl/EbpqxKlXbS/Nihmh7GeKFMHJOengtUsAicLvarJNdCCKFIj/TalVcslQxZAlfb6i8xl78Zwc5nEoRxCUTxiQoSlY7iCSXXORqJuW9E2HJICqH9BlWBZUlHAPmBGOVBkK5d1fPmyjiuWkOpOjIdpF2LyVeZS8fvZD17aVyshdZIvTq6HMg2oCRiRLxlskoiuLwBOsO3ykKlgl4MAh4FDlktBNff66KMK+zjs4CRiaJR1DULn608g2didYg1S4keJ3LBE1kExYTthHWvpT1XnaX0SL1WwIxFpnhEv0hP5xQRIlzYJk6UnJkIGZHqudnipxUxA7CwEO66qsXCFrq8H4Hay9FyBc0M6WLZdhrlxlcImjAW5WjJl9kr5SyMxO8Gr1mvBpeoKsSwcGV+ulFWLKyTh0rWzMxsHKOToXelTxa8l6CKHQOhixsvHA7RG53C51LLHNHHIto02tJW8pa/huQlWmfb/lCKKtQRbNS6rMJ09wzn69IsdzruBvYRU+8JDsMCmtnDC7jxOicsvaCcxnvEp2LnPRFVLl2xyWffKRzEa/lGgCrglOHEkQO4YX6/b4eZStyxyBCwNOxZuNh6CcGF0sZyYVk12um19onqdGp4cVYuZLvG2/0l8pBpUhjzUoeOy332Gv5b9f+v15zLvEH6+hkTdSJTta1X3xU3LjvE1dV8htr3XMCgyt19iQkjkNEgSmGgyi23Hupe16EwcHgisw2yL6HKefs+6uuSkwh0+nFfyYvpJEJJ4Y3wYuRTYpwuLReFl/62N4ZToStV5p04MmIyDdRZJJfbbZX+vIR4Asunfb5wBvvdNoajUaj0fhM57UYcGg0Go1Go9F4VkTka4E/BvwuM9te+upDwPeIyJ8FPhf4APATLyGJjRfKO/Ek8VWa3QBvTc/VJ8iP++5Jn5903tXXZ+Ody8mnSd/TpubqlpBPc8X+6f3lJ8mX0/T4crArr09O31tnEYDi3W3+0N0/yJ/8136Mex/4Jc4/do9f/PnfwHvf8wne/Rs/TDxf8V983+/lz33sLxLT/SthCtfPFLkuVVfTH4npzRvT++TZDZfjeVwuvL16+PRx3/T5VeBZ6++z1ONnr/NtwKHRaDQajcZrj4h8L/BVwLtE5CPAn6bsStEDP1S3EP1xM/s2M/sZEfk+4P+lLLX4w2b2ov532mg0Go3GZy1twKHRaDQajcZrj5l94zWHv+sx5/8Z4M+8uBQ1Go1Go9FoAw6NRqPRaDQajUbjM4iLbR+fjXdaAnpZFvm84xVUj8AyxoJIz+euv4xvf/c/xx/50M+wvPsDTH/yB/mGv/KV/B/zL5PzGyAfw2zBbAHuA3/hhnRdXqrxqohTL8sMPxt4VfL9ybwWAw6KFdnjMCEu0e0GVDMqhq8y1U4zssq41cxqGMnZMc2BvHiWqYNcKmGR0RkiVsVoe4FaaTQHuZ9PSP1+L8sTsSoALO/34rBOIwIETWiI+LCwXu3IWUlZ6ZeuiMCkCO+cQOcSWqVrWiV4ZOhdESsODgYtEjERI2jCDAaXWTvFqzG4hJOAE8GL4kRQHl2Nk3KRqM1JGFyRoe1lfIYRszBlZbEi6XNVmpaqDHHJxpSFMenBcZtMmBNMTpiSchblIKuLGZZqrZuS0GkRKU6pvIqr6RMhmzFn2CVlm1yVBlZZpRk5X4griwiyyCLHnHEipCwkM8a0l0QKa1+kj9mqwLH+zbVPXHK5//33S4Y5G11ttIKwVWFM5XgQwQlAEUrmDOfRcz4NHE0909RX6SVEq2ms+e5qPmcEqWm3ek6p1xfk+mOTyWTJYKBkvDliDWeWBYBgHkXxB11cIkq5QW+eScZDeFI0nTU+JUoEg4SrnxNqUsV/F5ZGJ0KuddVJESp2LhFcLhLI+l1fxYchlxRNS2BeAnuRezLFaWZQK3UcmM8H5rljieGQB/PcEZdAzEqufmInVImqEDQTqmTPidGpslLHYkZQWPnSVtYusmSl0xL/UVgYXKLT4XBtznKQyu4Fi71mVj5XiWAuwllgTMqchWzK4IroM1iH08DGC3d7irxWYZukCAu1CAezCRsPRyFx0s1FGrl44tgd2vTaRSYpMtpowpj8QZjpxIqctkoMexWOffmckpJmzzQOiGbmpWPKSqqiz66mYeXzhTRSjSCKc5EQFo6HHTEX8Wm3L8ew4F2q+UAV0ZYa1ONwCoPmQ/qSSRExqmGmReIrgiJFXKqG1rpDrWGlb1EUY+Mjg3M1D4twUYWDnHIvYaRqblPtx4NKEXZq+Q3wVu4ZQGMRimqtXYLiJBD0ou/fCySDZo594jgsiNhBDDw7JQahd5l7/czGR4JmYnLkpMToyLnkS+egt1IPOjXMiuSz9O1GyqUtKUVS6aSYZYNe9ANdrd/7Mvc1XwFccjhRnNSVsiasfGbW0i87uWi3jUaj0Wg0Gq8ar8WAQ6PRaDQajUaj0Xhanubp59NsLfjpctO2nNcdv+7Y232C+7jZDY97Er4/9nZnSDwZkY6ijNn/Xd66kkvvH91mVG4op+sli2V7SYDgbxHTOdl2fOTsR/gTZz/Cn/jNBvwYoKi8QbaxxGU3bcn5uHJ51jLa3++LyN/r6vPLnAVw3baTz4vXY3YDvN2NchuNRqPRaDQajUaj0Wg0HkOb4dBoNBqNRqPReI24/ATTrjn+sp78vZ2nmDdd87h7edp4rtu28PK1z7bB4tvjabfWfNy5z5unud+nSctNsyAePzvCbL4mPVdnN8BF2aXDWY9ytR4IIoE+vIcvc1/DF/QrvvI9Ewb8rl//C3zRl/803VcM/OPv+ABf+kM/fdjq0mzi8gwGkVCPJ95afx4X/9Ny3Vadz4N3oj4/K69imt55XpsBBxFDXEJdxlX/weWfGxVDFMQlQrcQ5qWsc46eOHUAdMkdzl+yHpwBcnA6GJ3CyiXUJXJyOC1rbkXAi+EUnJV1tHHqyFlxdS2uiCFqiMv0w1TOWUJZw+4ynQMRYeONo658PydX11yXtc+DK+vKQ413j1MjWK5r5sva5pVLbHxxOigwuIsc2a+xl7pWuNv7G+DgfLhuaparjgvvEhvv2HhlcGV9tZPiJ5h9JqMENWIubgoQInU9cxJEio9iqFkeqsthcPu14UZQI5mW9eJibHxCREmmgOClni+wc8JixY0AZV3/ygsiSqflXoNCEFh56hrzsq76sBa9pmPjrdaBYjgYU4nLa7mu0+J4cFLW469ddYVQ/R5iZPYOADmssfcCSaSuJZdDPEFLOpYsqMBS/QCCY7IODBYS2TIqSiQWR4N5Ah41xcgoSibjcXgcawnFvWAgJmQ6vDl2siWTcXg6PMkSTkpT1/rP1Wl23hyC4KvtYX/P1Hqy9nAcMkdh4WTYEVziTj9xu+sYnHGnnxj23gQX8NU5ImI4l/Ca6KofoVOlc4kUPbm2xa6ec7mddxoJLnO7AzNH5+DYZ066CYCNH9h4JZljTMbtzrjXR253M7eGEYCT0NXXhd5FbgWjt764U9RISYq/RYwoxspnjus6fV9dEUE92+QYU8mQOStjcmzmgQd4gggrZ6yr+yHjCFrqUhBj7Ys3Ze0Sg4u46oaIc0BdPuSTYiTk4E0pa/qNzmWCZIIaaw+G8q5hKj6IrvxnJWc9TFPzYqxd8UksVhwwt0Kkdwkvxi46Vl4JPqIus1lvSx+0dNVzkRlWI8PZzMpHjn3iVucBR7LiJlg54Xa3HMorA0NWoglejcWEIy/0iz94E0JYajmXtnAUZoImZnV4zWyql2LtMosJxymTTLkdEoPLJBMG5w4ej94VL8raF3dHqH6QOQtTErZRmLIj5IBIyR2HZ3AJX10Va1f6xI1f2PiFo27GSWYXA3Otm6F6cm5X/4ZSyitGf3CUdNV30en+/PzIBFgRI15yLAy13J3JwefgtNSfC19HyWtnenA2WO2vBmdkMzotHpsjLwcnT6PRaDQajcaryGsz4NBoNBqNRqPRaNz8tPBlP0V8u097nzWsp4nnpqfILzuPPpN4ltkbT4MeXgXBalkJ9QkigGUQj+BQ7Uh5h3fHfDD8br7t/Z5eM1/z5T/B0ed8iH/yk1/Cn/8H/yJ/d/cG/9kv/xq7H14xLb8KfPSRtNojMxUSZo+b1XCZV7Uu3TQDqvGyaA6HRqPRaDQajUaj0Wg0Gs+dNuDQaDQajUaj0Wg0Go1G47nTllQ0Go1Go9FoNBqfdVyeSv+qCWFe1FaC8HRy0afdFvNZt2B0OD0i2+6SPFIQ6SnbUl6SN+7Dlv22mAGTdNjuEsDphiV+kp+Kf4Vv+dnqZ/sZEF0xhP+PlbvPe+T9HLv3sF0+yfVblF5N8+u+DOFynX5Vlle8Kul4UTy+/3gtBhwMIWfFkiNnwUzJVaQlcJBm5VPH/OYxcfFkE1JW4tQxV2mk3/XE6En5QtAWk7LEi2zYSxPT4lnm7kKAV4Vh2YpQMCbHMgemuYStUkWS24FpN5CTkrMyzYE5+iIQgyoX4yCQc1WY2GsRhO2FhSqQqtRSDexS3SzCwnKgSCBBReo1kA9SwkvixCo5y5Twr1Ikk/aING9wRu+qjLEKzVKVne2FZ50rojhvxpiKlXJwRRrZVVliNsFLKa2gVZxGkaz1Cp0r8Q6u6NaWLCxZcFLEd0mE3oFkIQlFSKlFGqf779jLMTPHQQ+CzN4VMWAQZTFhTrByRTS3ZEERele69F6LDHJwhkqRd/bOGLQIRffl7KroDyCbVsFnSZdWWeY+/8yEzmUGNWYvhAxzlkPZzNlB7lgsk8ioKZGEN0fA0ePLT4OBQ8kYHY4gytpVuV1WpuzozONQJpuIEgnm6XBAf/h9iZLorWNFqbeJjEPpxKEiBC3ySF/76KHef6eZVZjxPrEJC73C2mWOwkTnE3N0LNkVEWt2qCbMFBVj7Rd6vah0ZkKuIsY7w47eLzgfsSz0mllXIeJJyIxJa51JHHUz2YSNTxx5h1Hq/MoZxz5yZ9hxa3VONuFoXAFw3E30PnISEj2BwaVDGrTKPp0aveYqAMwMPiKX2oMSmLOydsbohfXSEazHK1XemvEC0TIr54p41IHk0k5KmyrxpuRJc8BcxtV25tTIubQnX/uFrqZp8LHIHJ0hCO/uR961Ome92iEuozUM1cTKJVa+fB6T1vJZuN1NiBjb6Fk7R9fPDKsR5yM5OXQsQs7OJYbjc1anR2zCzFEYWM2OHOTQ33YKG78c+iGliF+TCb2W8j/vPMPkGWxDUENduY8inhWOuiKNXLIjJEcQK+XoI4OVtj9l4ThEVr4ISde+o3OJzkV6V36qV66IJr0ag0pp3yqcR2XJjlXuCdLjtae3FUOVdypG53qC2KGsN2HGu0Rwmd1S7NwipQw2oQglS/s2claWJRRhcJUNB5NrpZFQZLJFDgobHw/9sBMrImIxOpdwkov8WEp/n01Ipgf5JICrnXdf68kYtEkjG41Go9FovNK8FgMOjUaj0Wg0Go1G4bon1M/6pPlqeE/aXvPtbFP5drfJvMzlJ/1PejL/dkYg92FfDfNxsx+um33wrHE/Lr6r8ezZyxTjM8b1pLiv43GzG+qDvbp9JGjdWvLiu5vjSKT84MoxxekKpyvMMiKKWa57WDlW4S4bvUcnayY7Y8Nt1nbEe7lFxvgbP/JTuP/7H/F//eWv4f5uw3f9/Hv566d/md38BiOf4L78ImbPkmcve3vZt8tNdfBl3Men0x+9CF7u04nmcGg0Go1Go9FoNBqNRqPx3GkzHBqNRqPRaDQarxH7J983rYt+u0/bLz/ZfZYnlM9zm87rrrHHfPe84r06o+Fx7+XS57fLozMXypkUp0YAACAASURBVIyCJz2hTi/9OXGhpOLCwfBsqB4zhHv88/ov88WrO7x/k/nEpPzTs4V/Jh/l13iDJe8AcBIQlMjElM8QUX7NPsJD6fkYEG1i9eU/W7ey/FtXYhKM5VJ1eJH151XkZd7Hq5aHN7Xhm2ZOPV9/Spvh0Gg0Go1Go9FoNBqNRuO589rMcMhJWRZfZItZMJODMHIvzUpnK5bz1UHoFbNjd75imvqDSHEcB7bJcx49mxiKoG1KzOnC+LpkZT5fcXq24XTqmZJHxZiTI1V52hg9u+2Kh7s1uxgYk3C+dOzePObs4TFLDMTomGLgdBoO12WDMQlnUw/A+RLYJmHKRrK6Ok04iNPGWOIuoktlyXqQHS4mRU4mHCSJ0YSYhWhFIKn1eIYqyryUX1ZGtVSKFHD/F6qIrtOMF3cId583F2GVY0WieDEqLfv0yKPlcxndi9Eo6ZyyEg2Wmk/7dGaKMM2rMOeLa52WOHz9SwYpcxDuuRrnXlbYOSPFi4QEMbKAV6n6RPAKRpG4levlIBUs+ViEbslKWR+NA3MVjqaa3+WqSyLTK/d9Wf6pFOmlQ0AUZ0Img8FARy8OR8mPxRxaxwe9KCvn6LXUFVCcCD6X121eMTHR4enV1UT0ZDLOHCs61upZLKNGlUQKIlLTdJFGqfmvYqhmgl9Y+YWVz6x8ETwGl4AOv2SmGJgXTxcgxtKmeh8RsVKuWZjGIm/NWdj0I05yzZsScXCJXKWOS83AJSspP1rHOoVRBJVc5X2JvpsJY8JV2evKL/RhYeUTDsfgJkQyKQeW7A5lVuSt+SBHdZqx2iVMWemSsvLCOguDOvo84KSISvejtr0avZY6spe5Oi31Kbhc7n0OzHN3IXuUfbsvAsGguYhZ1aqwtpxTyt1Yhci6n3A+Ibp/wiJIFQ+uXbl+qRLKwSXW3YyZVHklOB8JqxGRjnG3wrlU5JQu4bqlSHIlVzEsDDUf5ky950xGCORSrtWo7cRYcqmbQQS10ivsBaGHtqepXlcFolyIbDuX6NXX9pgJknGuyjcl1/ws6eiVImzUuvY4KeqMwSm9g25xCK6kT0p4nUskU7JxKf9ANeNdYk7+kO9Q+pMlO7IIQRNz9MxLh3ORlEuL9FUIKbVNixi675vr51DbUNB8EECWOlLqXOcSTnNt7UWUDJDyW58JSM0nM2Fw7lA/Go1Go9FoNF5FXpsBh0aj0Wg0Go1Xl+cpWrtpqcBN5z7rVNhnCf9pw3wnuDod+Op3132+Trp4lavfXV4y8DTX3xTmdem47vv94OJ1Wxbu0Ru+v65cXJUrpkPY5bNdbLUIIB4sXnNcH9me8S2fn8T+/EvX2aV0ypV8LPH7S+/lke8K+ZErLkV2zbFrE8W+DPbbSj5OPin4mn/XyS33KCLu4l5RzJaa1v117tL5GZHA+1Zfymn6GH9/9z38g53HP7zDF3f/Ol+gt/jc9B6iRhY3YWQWGznmHr0NBDpO8hqHMFviC/oV7xmE/3b3szxaP+p9VqmlUF6zjTzdVp+vGze1y8ttC17cvd8U/00LCV50GTypn7qur7vuuucnmmxLKhqNRqPRaDQajUaj0Wg8d9oMh0aj0Wg0Go1Pm+c5A+BZwrpuK8HnGf7bOf9F8azyxGe57mm++3QlkDcJIZ/miefTnHOdXDE98s0jKThslShXjl+eVaBg6eJ9fYouuEdnI4hilspMCqtptevTbI/EdnkGhFzz/ZN4VhGiPdW2mjefczm+dOlebwrp0TwwW/jE9HN1OWJdUqs9H7af5g1bE2Viimd1dkWRRj7MbyCixDSi6sm5pO3vTufwIN8gr7TDcePtyS1fL26agXR5tsmLjBveKli9aVbOi+amuG6SwV73/fOlzXBoNBqNRqPRaDQajUaj8dx5LWY4iBjqMk4zzke6fmbVzaxdplMt8kETrAq2pAruVAwzISZHjB7vEtPcHWSHyaRKy4p8z1f5VgbSErAqDLssRwxqLHuBYxUGBk0oRsxKzo5sQs5CysqSHDFrFbEVOVoRDCoqRqbIF52A1RFlJ9CpMbhM0IRTI4mwZBhc4tgXqdzGR+52iftd4GwRVr4I/0TKiHMRvMHKZ3o1pgxBoFMhiBBUGBysXObYJ066mbVfcDVdt6LnLDgGl9n4SNDMnBxOynq0jS+jr4Pu892x5CIg1CrU2/iMk5LPzoyVy6XcXK6yuyLbW7t0kK9BkaWJwLEvEj8zwYnU/CvpPvaZ5IWuCvlEYO0yQYsEE2Dl46Gsz5bAaVSOfbmfVKVrcy4SubXLZEp6zqOymBBkfw9FyrdHqwTOu8TKRwYX6LRs0bXxRp9LeIsJgxobn5iyoChDle8tuUgynRR5YTYjZGWxzNr5Q74ahsT+EPfaOY6DMrgyFjm4IgMdU5HYTfNAMMdaAhvn6FXZJcWAWMNeO2XOypJrPrlSpoMTvJZ6A3AcMrdC5ChMHB+dsVrvGKeedz+8xcZH7p08wGmm360wE3q/0IWIc5EQFlYmHMXAoJlOi0RRxHAusV7tGPoJgG6YSHEv7Cuyx5XL9M6V68TIJgcJY697SaGwcplNWDgedqxXJX0bH3GSub05o+9m7r55j7UMrPwZ3iUMOUgqi4TQDvK+3kecZnz9SybErLU/EG4FZT2uGRy1D8p1DFvpXBnF7VxGcqk/XjPBRXy1ceakuBqHEyvPoRQ6Eiu/kGu92+M1M6jhvHF72HLr6JR+vSOsRtIcSNHRdwsn3VSFkYqTwOASd1dbbq/OSVlZbTcMzvA+0R1tcT5hpnT9zHE/4jQT1hP9MHE8jNxbes7jRf93GpVkUvJHSv8qAq62tSl6nGTGpHy0C6zHI3otffcQZgaX6VXwLlURbKZ3iV6ttsXEJizMyTE4z3FYuNWPANzqNgw+MoS59gnCUUgc+XRo67Mq2YQxlXW0Ywp8Mp4wyRnBOgYXubs+53QcWLsNnSvl7TWz7ia6EA8CxpiVEIukOGjCST3XJUTyI6JOr0bnSh871D5iLyku7Rd6l9DaHxX5bO3r1eg00vkSx/54zkpGiKm87n+XDmJVzaSsRVJK4/XhVfEgNBpXuVov0xPf72cAXN1x8dOr4c+zfbzd9vYi2+leCDyi0vHN7/p2vu03/QI/+OEv4r//5C/wK9ufBMtlK8vLz4SrZ6Nw2dPQKHw6M5CeJ0+azfSyeZrZVi+GNsOh0Wg0Go1Go9FoNBqNxnOnDTg0Go1Go9FoNBqNRqPReO68FksqGo1Go9FoNF5vXsUpto3GZypvt70973ZatuHsu/eR8sT7ht/Mt9z7jXzeeuRXtonf9iM/hvGjiAScDphlRNaHrTsBct1q0yxjFotQcv/6QtL8uvG4xYXvVN48bsvdl8nTLrx8sel8LQYcnCaG1YjvZ/wwIS6zOV9zu1s4T8o2KhnwJ+cMU2Dz8IilOhiG1cg8dyxLKOtis9Y14BmFulY71XW1xYGQTMhJWa92rPyCRo93GTPY+GLpNROcZo76ERVj40tBdesdJ9Ex7VZMc0DEWJLneIpsfMeY9m6F4mboNRHUGJxgTvACvYN7feRzVyN3V1u8S8TkSKb0LnKndyjGrWEsboKoDE6r+yGTrazt7RU6B7dCLK5Uc3QuMzhHUKVTOPLGrRA5CTN3hh3Hw4iIFe9FUrbJ0WvmVpjpXGJOjik7nHRswoJS8kvECNpzHpW1v1gbfxIig5a131MWjnzmJCx0+zXNyTG4xOAS2YTeeYboCeLICLe7hcGVPOqX0vnGLAwucxRKGINLJCsujE4zKx9Z+wWAVX3NJjyYBjZLx8pHjsNMrn6BlEv6jsJS1qhr4nTpGJPDaebYLwTNrMOMU2O7BNZhZjWM9Cbc7mZOQs955xDgbpdIBichsZjQa7nnZMJWjWgOL7BUH4UTIVlxFIRc1uBvvDK44u0wIJmr92EH90anpb5qdYMoglNYJw8JOlWCgpqQTUlmCEqvwuD2HVCZ5LR3NnQ13FAdCXe7hXv9yK3Vjs3xOcOtU+5Fz+c/vE3vI+969ycRl1mfr+lPJ8yE4CPeR0K3oJo5MeF2N7HxXVkL35e8976s5TcT+nXxEeynXG3WW4594sh7boXiyQguH9bNb3wimmAot7uluApuPeDo9kNSctw9P8KpcXJ8yrAaedcnz7nbHTH4SAgRrwmviU6NZOVenZbw932Ck9LmnVh1eOTabpQNHWtv1RVhLFlBM111TAwuE0QYnLEJM7c356VNuEg/TPSbHatuohsHMoJZyftNmIlZS7lS+om1ixyF4jo4WW25ffdN1ncfEI52AKQ54Hzi3Q9OcZKJ2ZX66iLvPrnPyckpcfHc22443q5KP7oeETVWtQxufeIeMXrcemR1dM7d44cHn0HKxXPzYO54sHhWYTl4CJxmOh9LeWppwycxsPGBjQ2lv1mNnKzPud1FxqR4l1CxEo4U982UlTv9jqN+ImXhNHpOupHbq3NEjLvdnVoGEa9Gb0Kv1Y9RHQ77urTyjk0WVk7plx6vfXE4+Mjto1OcZk7OTqprI9H7hc1qR9fNqKZ6z8o2BpwY6zDjXaJzkb5b6LsZ5xJOM4OLDC7XdlzKfp8WoLpnyu/Nvu7u827vgQiu1je9sFmbCb66IlwuzgoneghXAau+k+ZwaDQajUaj8SrzWgw4NBqNRqPRaDQajcarjuAR6RHxOF3xO8Lv4Qf//P/I8tu/AvnQ3+P4T/1DUj6tW2omQDCbyPmshnDTivd85fPLfnr+qvAq5MOrkIbreDXS1RwOjUaj0Wg0Go1Go9FoNJ47bYZDo9FoNBqNRqPRaHwaiAx0/i6b8G6mdMaX6O/kv/6yT/Jbvup/4Qv/yG/no+c/Vs/c1ter2zleLJKT+v6t22Huz28L6m5mnzevxtP9Rpvh0Gg0Go1Go9FoNBqNRuMF8EJnOIjIh4FTygKlaGa/VUTuAn8NeD/wYeAbzOzNx4WjLrO68xA/zGg347qF9YNjNn6h044tMCWHrBLh9hnr26fMu54UHT4sdN3MEovAscgNM74KvDqX6HwEYO0yo9PDKMx6s+Womwhazhuc4840AL4IwLoZkSL7G1xGBIY7D3HdQvdwpp87vEtkUzbj6iCWNAOnhtcibHNSBIsGeIVOi6zvfUen3D1+SPCRmBw5O3q/AmCJnqGbWY8Da5eZUhFnKuClCDCdUMR7YWEXPZkiT0wGS84kKxIyr5nOJdbdzNFqi4gxTj2rsDBoLhI9V147ihBtdA6t7wUIknE1XrEiMnRieDFwmTkVgeE+riAZpyU/BhdxmklZ6TUz1TzB7CJ9motY0wSVkkeDSwQxBhdJpkXyWD/vy3bTj6SsqBhz9szZESTjtdx/p5kIOKB3pR54zZzHUMtKSlm5zFE/ATBFj1kZPfVVAvdovTccQtDMkors0UkZmU41/1VgyUUKmcxIGaLBlI0lZ0Iu9zml8v0uJVSEbIaKMCepskNqecKYDE0w5sTIgmbBJyGaMedMtEzC8KmIKrcpk6yk3YurwtTy52rYvpa914TvZ8J6oh9G1qHUfQ2JbrNDXWaZA9vdipyVGEsbWZaA1jZnJkzRF4FrUmBGa5ucdz3z3LFNjmkJByHh2mdOqhw0ZQGEmEsL3Y/vOzF6vzCsRrrVxLAaWXczTjPOJ5yPtf0++jRgzp6lykbnrEzJk63IIpMqZjCmwC56xuSYkzJnYc7GRAR6/CXRX8xKzMX2OLhMUmHtEpswc7Q5I2dHjK7cW4iEsNR2mommh/pUJJQlTUsu9SfU+t53M/3JOW41Iz5BVuIcSLGcp2JVhpnpfeTWrYcMmy3L2OOr3HDeDqSxJ24HXD+XMgxLKZel/CSEENkMI5vdXESxyeO1SDRTFWRiQkqlD0lZmWJgip45ObJBprR7kYx3iZVLeC2yRKoAsnORlJU5OY76iTvHD5li4GTu2fQTq2E8iBfH5InZMWdhMZiy0CWHmdR+TWq5CnMWYjaiJIzMwswYO5xLHK/P2fjInBzBRdbdxDCM+G45SBmX5AjTUH4Huom+Wwi+fK9qOJ/QmFGxInA0SJQyo9bLfXpSDXMvldT6m1HaXak/2YRQfw9KXXI1HUqs9aDULz30S5nSh7TnN41Go9FoNF5l3okZDv+qmX2pmf3W+vmPAz9sZh8Afrh+bjQajUaj0Wg0Go3XDAEcTlfc634D3/FFH+T+936Sv/1HP8Tf/PCvY/NfPuCj5z9O3WPo0t9V9sczRqrbXmbeupzi8mvjrdyUv42XxctYUvH1wHfX998N/L6XkIZGo9FoNBqNRqPRaDQaL5AXLY004AelzBP9H8zsO4H3mtlHAczsoyLynusuFJFvBb4V4PM24QUns9FoNBqNRqPxmc1VmZxwsUDvpieiT3NO47OHi+WZKmu+cPM7Oc4nfMN77vH7v/ined+v/2f8p3/1S/j3/90JswX4795W2I8/p9XHxuvFix5w+B1m9kYdVPghEfm5p72wDk58J8AH761bi2o0Go1Go9FoNBqNRuM14oUOOJjZG/X14yLy/cCXA78qIp9TZzd8DvDxJ4UjLhM2O7RfEM3onJEqHCzCN2HKClGQEOmOt/hhYtquqqjNk5JCAOeKgNBLkRf2PrIZdliVtsUsbJMyjT0+RDb9SB8cvV+YYmB9dsKbeJIpKRUBXBG9gWK4fgGK6LJPSjdMeB+5v10zuCPmfCER9C4RNLPxmdPFMee9BA9WvsjMVsNE6GZyUnIVhuUs7KR/Sz6lOizjBILCymXu9QufsznjbO7odEDpCKqIyEFWGarIcQgzq2FCqsisH4ts71AOFJFfqoK2sd5/MiGJMmdlTEXQWMq9yNCUIskkQ18FkHsOMsWsRCviy2jCVGVoexFkMilCPoooLUgRSGYxkilLVrbJFYlkcgTNUNO+l9SZlbCpArYlO6bkSt0BgnikihpPl8A2KV5gqGLIbMIUAw/nkvcn44BqZsruIIB0UuKTKoi7vl2UtUx6aVujaEUOaVY2QMpVBJnMWA7HLjZHigZLMpxIOSfDNmW8CJMlIplkmWhGMiNaZqbkx2LGnItI8pAmDK2bMGkdYFeBIMbKLxytt/QnZ4hLzHPHbgkkU+btQOhnAOa5482zY4Ir8ru9ENBpkSIuBqdLx/37t8hZ6boZX8uo62bOzo84W4p4cJwGnBgnIXEcllruVaS3bwdW6oiZkLKSspa81yLzM5Mip1Rj6GYGV66Z5sDZNHA2d+yiVvnehZAv5EzMpW8Zo6/yRmExYUrCko1IPpRvrxkFTqNjsdKp3goL0YTjsHB7c8b6aMvZw2N240AIC85HQm3jXXJMsdS9IcyskyeoVclgkauuXeIkzJzceshw9yE5OZaHG8bTDeenG3bjwHbqmVORdVYXKMNmS7fZYSZ4TWRg3A2sTteIGm6YEZfoupndWCSJooZIRjUhFCHkPm/23k0nRQK6ZEfKpW9KWYimB1miw5GBFD0hRAYXWVcBqVTRp4jRLx1OMyfrLXfu3Geaes7mjuPVji4sTHMHtS/YLV2RRu7/TCCXMtzHW4SbpZ4nIoKilPaekmMYRjZhwUwYwsJqGFltdqiPhBBRV9rF+VTb+dFZEQSrMe4GYnTkLCzRH+SPGcFhpX+htO+8r5tW2lXWjNY+c99HJBEkWe0H3UGiuqSS33P2tQ6WfmrJylIlmsmEXdJDGhqNxtNw9Xf5adbDP6818+2J9OuPoLJGxNOHO3xt/3V88E4RpP/KzvEl/9vPk9IW47vq7IZyzfXlft1xu/L9VeyG943Gq80LcziIyEZEjvfvgX8D+H+ADwHfVE/7JuAHXlQaGo1Go9FoNBqNRqPRaLwcXuQMh/cC3y8i+3i+x8z+loj8JPB9IvLNwC8Bf+AFpqHRaDQajUaj0XjJvA5PpF+lGVMvMr+uujyuOUMGzMa3HM+2BYPtdMb3z9/Fh843OF3RuQ2Dv81ZOq2zG/azSPfPdjNgiHR4d4uUR3I+vZSei2fAsk+fKFh+9PUt6LXp/Ozhpjq7n2t4mHP4DqRhH9fVNFzmnegHnmc7vpiN/enwwgYczOwXgQ9ec/xTwFe/qHgbjUaj0Wh89iEifwn4PcDHzew31WN3gb8GvB/4MPANZvamlKch3wH8m8AW+A/M7O+/jHQ3Go1Go/GZzMvYFrPRaDQajUbjefM/AV975dgfB37YzD4A/HD9DPB1wAfq37cCf+EdSmOj0Wg0Gp9VvOhdKp4PBpYFi4qh5MUxTx3nMbCLynksorB01iNqaDcjQfE+YlnIVSZnVa41+IiTzCbMbPqRo805KXnu9BPbpKxdZlkCPkROjs5QNXxY2G1XDL/2riKrM5iXQPCRUKV2rsoQXb/gVjOiRXbpfOLkzbtsfGLOZaJUHxaCi/Q+crdb2EXlNAqdGoMrwjgzQTWhrvzl5Ah+IVbxWEyOjKBCFdgJa58OErGNT9zpJ06GLetuoneRZMcEDXgRgsLgMoNLbMLM0E90/UQ/jIRuYZ47HowDc3Ks/ELnYhHxVRFkBqjCPtVcxYdVRFmFek4MFUNNEK0yTL+wZCWZ4tTwLqMYkss1Xi7kiEUWeTEuFqs8svoDiblI6vZiu+AS+dLUn71QUMQO+SJiiFyEN1cx5ZwvhG5zVmIWkhShYJEKOrZLYJscXfJMsWzXOidXzrUy6Ujqve/FkV6L+C9oxonSOehcJqM4KVPnVKxcLwKXxJHlHuwRtZCTInRMl2ZlFclkxkRIJOzSlK1kxkImklCEjBHNyFUUCSUNUiWiXiCoEaTUaRUjhEg42ZY2WMsu5iJXHaJDNBOTY0n+0NYslLz3LuElVyGlcT4NpKysqlDS+yIRTEmLDDM75sUzVKFk7xJmRVQYszuIRff5fbjP6FnGjhT9oW1MU08/TwxhZuONoKnWmxLOfrLdXpwaNOE1oWIs2eH28kY1tBZINkoe17o5uMTgIl6K3FDFWPlIysJRmFgNI+ISy1LqzDx3jLsVziVO1ueYKdNc6tLx5hzvEnce3sLVNCVTNj5yZ9ixuXcfd7SDsxXLvGbcDezG+hcDc3J0tQ2oGC5EhrsPETVWYS6yweRYpo5+PaL9AlkOokQ9iFa1CHezY0yebXK1rVHyyKUiBL1mmt1+4mIiseSOcTcUae++/mopxzl6nOba/jJdmHHdQtfNrGufmrOyLAGr5TRHR8qXBbmlfPKl/r2UCyzZmGXGyGQyU3IsMXBreMBRNzEnR3CxyEv70l+7EEsYWTjZrVExjo7P8KH0hzG52i+X3wg7SCKNoEavufSPV4SxvopFu1r/skiRDO/7BS11U2t724dpUUhOHunTXNZaP/f9x+swTfvZEZH3UUTTBvykmX3sSdeY2Y+KyPuvHP564Kvq++8G/g7wx+rx/9nMDPhxEbm9F1o/lxtoNF5LPjP7k7fy5Pu8aZmCSE/n73Kr+3z+4PG/xE8+OOOhnPGPp79DTPe5mEJ/+J/slXBnlviJa9KTLn2qfb6l/UUlXEvXXPfZzuUtbi+zL4erefai0iA1rsvblr7opRyPS8+ex20FzKX3T9oW+HJYV+N4Mm2GQ6PRaDQajVcGEfkW4CeAfwf4/ZQBgT/0NoN7734Qob6+px7/POCXL533kXrsuvR8q4j8lIj81NtMQ6PRaDQan7W8HjMcGo1Go9FofLbwR4HfUp1PiMg94P8E/tJzjONJe85dHDT7TuA7a1raI8Wn5kVtA3ndE7vLn582LTdd97zS/U5sg/mscVx9Wtmq85MpQsfOv5uvW/3bfP3n7/jGf++vM33qV/hXvvPX8bPz/07OI2YTIqG84jASj5VS4uts1HSIo3BVOngTrexuljW+LPbpcVyk5639Vd1I+x1Ky3Wfr/v5e5r+4CaB5JOvbTMcGo1Go9FovEp8BDi99PmUR2cjPAu/KiKfA1BfP34pji+4dN7nA2+8zTgajUaj0WjcwOsxw8EESw7zF6NXqlbXctc11SYs949w/YKZQhZiLLe3xEDMjpjK2nCrAzQZwWnG+bK+RynLpDJ17fAccC7hfCKEhdmVNdrJIJswz+Xz3t2QsrKcrtFuwW/K2i/Rso7aa8KLEcRwe39AdqgYvUtsfGIxR1fXAZvBbunYjQM5O1TTwUcQY1knH5Mjm+A1Mzgh1vcljcLgEp0r6+M3Q0nPJ3Ybcl37rjUdTjLBx5IXLuG6SMhlLfXKL2XNslh1HxTHwVLdCRmYkxJUGZMyZ8EJZAwzWEzwJbsJmgmSkbo+PplUV0VZ07zsxQwUJ4cCYyr+DRFjMWFOypShz8UlsUuOXMssZsGJMiZHr+7gbYhZ8SkzJk/MWtaCJ8eSlTk5tkkJaqQlVJeDchYv7uU0ekSM06nnU+OKh3MgiHE2DaWckmPKsGTIAnNWspU45qR4McZaVlYHALMJS4aYi2Nh/zfnzGQJEgQp+Tvluq4eQxCSOZZcnA+55l80Y7FiJIh1zXqmhD1ZYiGSqrEgWWbJwmKZIIoidZS9rAZXuWgHu+h5OPXsxp54tiKOHaenR5zVur8bB9ybtwB48+yY86Wj03hYh54pdTZTnAtLVs6nvtx/8gxhJuSEanEClDYoTDEQNB8cHVpHTpMJyYQ5C2OSWleUKQbG3VDStF1xvnSoGGfbNV03o3ox8jpNPfGSU2Dfq+TqJzGEbBx8JbmmaX8PyYwsxjYJ59Gz8RHnMk7KqksnpU1lKQ4IMyFOHUsMzNGzxMD2fI1zieCrFyWXe/HVCTO4SDI91BcRo/eRsNmBGqiRpsA8dcxzx27pDnXaaS55lBzT2ZrV8oD5fFXyKCnT3DGPPc4nlofrkodzxxwDefHkxTHNgYfbNadLx3n0jKm012ilnXpLxOyYosecsCRlSp5d9KUfSLBQnDUPT49Zouc8hupkcezmjtNpICM8mHo2fmE3DqzO1+TaD0xzIEbH2TRwFh0rlzhbes6i1P6z+l1qPVlqHu5dMqlmnqBkyUxZGefuTOiIagAAIABJREFU8LuglLIZp57N1KG+PG2Yxp557kj7sKMnmzDtVuzGobZCY7d0TNkxZ2UxYSXF35AuORz2/WWy0raS6aHOqRgpC9lduGVC7a/3TgonmaCZZPnQBuKlsIekh378M4xfAf6eiPwA5bHJ1wM/ISL/CYCZ/dlnCOtDwDcB/1V9/YFLx/9jEfmrwG8DHjR/w/PmRT2BvRru08Rz3Tk3Xfe80v1OPIF+1jjshveNmzH+hc3v5R99z49y9rf/Bn/uB/4tNn8qk+0NhO+/dJaBTfXdk59eP3rOow6HC94J/8DrzGVPxsuesXN55tDjyu3p6sfzS8+ne+7T9LdPjuv1GHBoNBqNRqPx2cI/rX979oMEx4+7SES+lyKIfJeIfAT405SBhu8TkW8Gfgn4A/X0v0nZEvOfULbF/A+fV+IbjUaj0Whc0AYcGo1Go9FovDKY2X8OICIbMzt/huu+8Yavvvqacw34w28vhY1Go9FoNJ6WNuDQaDQajUbjlUFEvgL4LuAI+EIR+SDwH5nZt7/clH0m8bKnH78KvE5yyGeN52nlkDdtefesXCc8/HR53nl6sR2gSllOmG8czxS8u0tKDzAiP3f+v9L9PkUYEfkejAWVNUbC6aZcIYpZJKXTK8LIq9JAh3e3yTaT8+kjcb5VyreXIV6WIl6X169jW37aevmk6/fCzUyRNV7H1a1KP11uajeX1Yj5kc9yWL78orfKvCzSvI6r9emdoUkjG41Go9FovEr8N8DvBj4FYGb/EPjKl5qiRqPRaDQab4vXYoaDIVhSLCqiRk7uyvcwZ2G6f0x3vD0cT/FCPrabO1QySyq3vBdyeZ/we1lYVs6jIyPsxoFx6glhoQtLEXllPVybrIjqALpuJlPkdePDI0I/I2qIS1hNq3cJJ0asErrd0qEYc3KYCV6NINCp4dWYs+Ns7jkZB1LyBL8UAWL0RU6Z3EFAphRRXTSKRA2qWE95OHestkfcXp2X67IyZ5hzZkxa/zznU0/n1oQQUZeZpwu5WqZI4ZwUyeLp0vFw8UVaiDAnwalxuiini5ADmBXZH4BXo9cyrhey47yK6GJWfBW+iRi7Gt9ZdDxclCDGYo7BZQQ4XYrIcRvLXa+d483ZH8bqFqNK7Wq8MdBpYjElSObB3HEWHWuXq2RSub947s+Otc9VbGmMSTlbhMWkjGGaJ+UifvvU1HG2FBngsFsB8GDxnC7C6ZIJKpxHZcnQq2ebtEhITTiPrv4Ji1KuiZltykw5sZCZWJhkprNAsFJ3FhLu0thgSEo2ZTE7jFGOOXLGRDDHKCOyl0NaZiEyyUIm482hCNGMiQWsQ2vdF4rIcsmlzUWD+3MRaT44P2J6WEbxc5VAWhWnbs+NmBxv7opkcHAOJ5mlyi61lu0uCdvkeHNcIQJBEykLQ1hQyZxPA6fRMSbPdu6LDDIXCejgqqQweeak7KIc5IHn0fFgGrizXZOyshsHpuhxWtp7zo5cJZOZIi08XzrG5FhyEUGOydFFz6zKUmWuS1Z20XMePadRa72AbUrsZMt5vMs2lTR2LjG4RFCPEzsISqfoi2jQhIfbNedzT+cjbg6lT3AZkYzVtpJqf5Cs3PcuBrYxsIueKXribkDezOQpsEwd09yxnXvO557zpWPJymLK2VL6ptOHx4SPT7z58Xvc3605i8o49cxjj6+yXN8tnJ5tGJdAGjumcWCuUsfz6DldSj1OJpxH4WwugsoperbJ01VJ5ZgcD5fAm7PjNGZ2smNMJzzclfu+Pwe2qfRd26XjU+OKOSsPFs/dTjmfBobzNfOyz7twKMNd0oO48iwWbeODRWv/olVGWfrW+7PwcDHOcmR058y2JXNc8nPuOD/bMEV/kI3OybM+37Ha7DATdtsV292K7dyXurtdoZrZ7lacT8OhfszJMVbp7OmiCLATJZrQaxHsXh7Rd1qEtECpI5e+tyqZDdEjQpVgOsbomZJjykrMJex9H79k4f7iiPb/s/fmwZJseWHe9ztLZlbVvbdfvwVmGPZVGmwZsIRhsCUPdiCzBIYIQkgCByA5BGE5BouwLRN2GGFh2TICIckLwsIIYxxYyDICDAS2DCMCW5ZmsMQ+EhoxDMvAvKW7762qzDzLz3+cU3Wr77vd7/Z73a+Xd74X9e69WZknf3m2qs485ztPpjVSVd8vctu1NXvafeVxfCJ6v3mc5JD3ep6ryiHvl0TycWieuv9555EN58R0A2dP+N5P/jy++Ku/j+tf9xGsp/eCGiChzAiOmF7g7k/kL25P9Zg7x3f+lDpd+Hnx98eZexEV3m2fQ+Hm65U3d2o3F8+fLt3rwXIo0rwTr38deixuODQajUaj0XjD8H4ReRugItIB7wB+6SHH1Gg0Go1G41XQplQ0Go1Go9F4lPgaitDxLcCvA58CNH9Do9G4jwjnIwkEsBhZ4ex1lv1H8aXXvprtjxTXQ/cnM+vpn3L+NL0ce7684f1+fq0PIM3Ga/OUNF4LbYRDo9FoNBqNR4lPUtUvO9wgIp8F/PRDiqfRaDQajcarpI1waDQajUaj8SjxV664rdFoNBqNxiPOYzHCQbOQk8VoQnNGqwzSi+KN0pkyRCYniyaz/z1ng6oh5iJYjNkSkkUERKrUyySMzXgTuOZnrnUdvVGcS4jkKpxLpGiJyRJykQCmLMxVTNdRpYXZErY9xiY0C2kaSGNPCg5TJWIKzEmYYxGPpZpeb5TeZo5cxpnMlA3b4PaSyyKWM8RkidnuBZZQpIGZIooM2WBFycpeenc69fQuEJKrojyYNDMmZZuEs+CxsqCziaOwYZ46xu3AGLpyLhWUIrLbVoHdaTT7u1VjFqRK+aYEvRW8gTmVZYK8lmVgRKTIz1RYR0dSoa/CM0MR9wGMybCJMFhBRLFVHDbnIjXcJsVHYc7n4kAnSkaYavkP0WFEibZI1mZRNtGyTQZvFJssczZso2Edy5I6RiCpso7CJhWZIJTr6bLBRsdZsJxF4SgZNsmhKozJsE0w5iLPm5NhysImFcmlz6bsl4Upw5QASl5NWRlzZCIyEQgSiBJJRLL2GAxREmhZUscgKBBUCVqWtMmq5XiZiDiiRJy6/XsZJdf/gyWSiWQSiUDE40iqjDnTZ0NXpZtZYJMMQ3Rs5o7pbEl/tMGYjEFJCCE50tYQktvLDVVLuakWSaNBGZMlZqpc0NHZhFGDs5nBB/puJqth5RKdLTJJVWGu5eRMruWckSpfnXOV7eUiLMx62CYE2UlLfWCOnqRgJdccLJQyL3ElldpnlPh3UsCdXHUThTEpsyZGs671VnGiDDZyrRNOg+OkC6hKFZiWNjvNHTGVtpSyIWppxy4lnE2lntsisE2pSDd3yzvthJLOZtLkgSU5OETKdcRk9/1Ipkg9Qy6C12nuufn803zgxWe4MfdMqbTjXf+nKohLbOaeKXrCZiBng3OxSGpzqcNTMgSFMZUyKe3UsY2OYHb13nIaLKdBOIuRrWxKnxA9Y23vAN4mcpVMblMRqQ42M6cixI1Vlrj0ht4FBj8zGMWbUvZeitA0aul7htr37drsOsKYMhsmgk5EnQgyF+litoxTzxgdQQ1zdOVzIXiW9gxT83Su0k8rmZgsVkt9DNnut6ds9nXASqlLu9qVdLcE1vnCUznDrtfMolhRqPXaijK4yOBnrMnM0ZGzwUqHE4fLdp/vudaJ3WfRLuYngboc5tuA50Tk6w7eOuHO6509RrSlKBuN1wtjjsn5jLu1OWefRjViTIe3K/7Q0efz5z73J3nus9/D93/rLfp/4wZZ/+dL0mjt+PHkSSu3x+cz5bG44dBoNBqNRuOJpwOOKN9Njg+23wK+5KFE1Gg0Go1G4zXRbjg0Go1Go9F46KjqO4F3ishfV9X3AYiIAY5U9dbDje5+8Hg8iWo0Hm/qKM18esk7DiUBBhHLtf4j+Xj953nnf/o3kd//LL/2X72LT/+B5/iN/+k9KN/L7UtU3ulcrV03HhaPT91rDodGo9FoNBqPEv+FiJyIyAr4ReA9IvIfPOygGo1Go9Fo3DtthEOj0Wg0Go1Hibeq6i0R+TLgR4A/Dbwb+OaHG9ZrpT0NbTwIWr26nZIXzl4n5xkloJoQsYBBMAz+TVz3H8Uv/LH30T/zt/nUb/qD/NL6BxGxePs0xqxQjWRdX+lcr43dCIpWho175fFp+4/NDQfNQo4GMUJOBmMS1uQiABTIKojJmC6gyZLHHlVDSoZQpWo74SIUedxOtqUqWB/obKoSyszQjwyLkfXZai9YkwM5lwg4m/A24l1k5RJGtAgoFxN2MZe0k8WZzHKx5dgFXjIdE2CNYk0ma2KwaT/U5MQHrMl7gWKusrJYZXxZDVPwJC3iMlWI2RCy7OV3O4pIzdKFjuPoqwTPkFSLTFAhZTgNReg2uMibRInBMQfPFDxQpGRWMlYyuaafVMp2o0iVDBop+WKlSNBESuwpg5p6HdmQ6vEpC6Na7E6gBlWCdl7u3kBnlHhwjpQhazkXFGGkNUXKFrVMAs417zqVUjdECSqEKiMsdaDEvzufFS1lKOcBZD2/HrsT7SFozevd9rKP0BnDwikhlH1273ujJC3X09siPHVG6I0wZoNViyEhGMyB/DBKwqiQyVU4J/uPJi9lv4RidSeUK//JJYOXBIPF4jDEfXq3D3PKB/1WEeFpLW9DjI7VMLNabVj4yBgdprYjqeLEMdl9WTqb93mwKztf9xtcZOkDzx7fYrnYslhumMaeZz74oTyzPMOazCZ0QEdU8CbTu4gziSOX6K3DRCEoxCpiFJShn6psL2ONcrTYsFhu9udfdlM53/qIPnR0Rhms4kzel38RE2bUFJFkb0x9T2r9NggWb2DhMr1NdDbS2ciULNf6ibO52+cbsBdo7svioC6lbLBViCiitb7u9qmiSzE4kwCY1ws0C91qy3KxZTsNJDWsgydQZJEhS1GE2sjZesl67hmTRYHBz6yundItJmwXMD4yRU+qbUxEWS03HJ1OdGZ1HosKfZU3WqO3iScNL5cXGgzegDdFBNrZTFIYupnOln5PgZvB7uugdxEjypgcvQ9cv1ZG0X/kzaeKaFSUk27FmGAwSmcUZxSLkjHMCbwp7dAnixGLYHA4OpPxNpLyLo8Mc3LMyaIq+H7G9oHF2ZY5dGzmHisZZxPOFdFlZyOqrpSLySxtZOU8QYWhCiB3/cKuzu3lnPu+ovT9RXqcWfnAspvpXWDZTXgfmGv9cTaVGKNlSo6DromUhaXr8E+QNPIALyIe+CLgv1bVIPJkXmij0Wg0Gk86bUpFo9FoNBqNR4m/CvwqsAL+roh8FEUc2Wg0Go1G4zHjsRnh0Gg0Go1G48lHVf8y8JcPNr1PRN7+sOK5f7RBGo0HQatXlxHTDc7zRjByxIcvfx9ffv0T+PRnX6Szkef+218kplvADwCgmpjjBy6k9KDzt5Vf49Xy+NSdNsKh0Wg0Go3GI4OIfKiIfKeI/Gj9+63AVzzksBqNRqPRaLwKrjTCQUS+Fvgu4BT4a8CnAv+Rqv74A4zt4PyK9RHjY/nbKNYlljYyGMXX2ybGZuxiJk/VPWASIbjqERBinauryn6utohWJ4ThxtxzGizqBGOU1VO3iMFhXcL7gKqwcJGFzQwusupHlostw2Jk4SLeJIyLiE3YxbSP3ySLMWk/F9qI7L0I3pb5z95kFi5yfRhRhTktbpuvG5MlqSFlwxRdmeftlKDF3zDX15gEZ8qc8aDlZ28sm+AZo2POQlZu8xSsk2HOwonvMCaTkmWaO2Iu85zzbV4Is3dZSJ2T3xslQ3UUyN5ZEOqc8FxfSYWcizmgzGkvzoDdnGdT568btPoDdnP+MyMGL4qt8+iNlLtlTpTO3u4JENjnaWdTyXPO95E6h3oQZUyGtTUMtsTsRclWmVJxYgAMNtdXYrCOMene67C0kWs+sXKWbTQMVljaxDqWSrlL05nMgGHKSrLgBYJSnRoOmwSjglVDpiORWNAzaWCgYyJgEDwOJ4I3hs5IzT9FEgRdEIgkHJ16LAYvBq+OrIqidDg6LIGMolgMgpC15FGoHgyhdA67eebUMjO2tIXBBlSh7+bShibhpJ8I2e7n8i9cqGVSrr84DyLX+pGFD1xbrrn+9It03YztIql6S7rqRckUh0LMpY3snC0Lm/C1nLOe3991NrE82tQ0ynz/4+MzxGZCsmSFxTByfHzG8dkxZ6Hn2CWsUVYusvIBg+Js8ZXMyeJM6SI3yTBnpTeCl+LZiLnkyVxdAMf9yPV+ZNnN3Jx6YjaM1RvjbMKwc4To3segFC8LGSQ6cjakVJwqpc7m4q/QzOADYpQ0e3IyLK7fYnW8JgSPkcytqWfOlq1KdaQUN8SNaeB07llHR8ilzPqjDbYL2MWM1rpqRMnJkpPBusTxsMWbjKF4VEp7EzqbWNS82ntPKN6FkA1n0bC0Fp+LI2PVj2RKuzBA52c6GxlsLJ6J6jXobGRYjHzwxnW21VljbUSMsvARK5mVn7neZWIWjnyiN8pgS15uomXMhqgWI8KN2OHoMWwQDCsX6Vzc92Ox9qWpenJyspgc8T5gbawekOLWsDYy9JnjYUsXPSLKHB1WcvV09HTm3Au08zbYg/aT6+eHVieJNRlnMgsfSjrVMwTsy86ajM0ZawySQWtlT9mQEaLK3Vdse3z565TvHP9x/fsfA/8L8J0PK6BGo/G4sft2YPHuab7pI7+YL/7nfpb/55+u+UM//1NM4bcp304VsEC6QzqPj5iv0XhUueoIhz9W18D+HOA54KuA//KBRdVoNBqNRuONyrOq+jco/xpAVSN3/tdAo9FoNBqNR5ir3nDYPUP5POC7VPUf8aQ+V2k0Go1Go/EwWYvIM9THiiLyGcDNhxvS/aB9bWrcb4TydL5xO8Kzq3+RP/vRX8Ov/9FPZvPfvIgBftcP/wJf8QvfyxyfRxC8exZrrlHvbQKCs89gZIXsB4FfNrpBuH/t+X6m1Xj9eBTK7FGI4WpcVRr5bhH5ceBjgK8XkWPOW2ej0Wg0Go3G/eLrgB8EPk5EfpoysvJLHm5IjUaj0Wg0Xg1XveHwx4FPAd6rqpv65OGrHlxYjUaj0Wg03oio6s+IyB8APonyCOc9qhoeclj3gTYP/P5yt7n1b5R598rVZhtdfBKqPP55tIt/Z+6CVf/RXPcfwVvzJ/I9X/pOfuv97+Gb/s9/hZ/6gU/g1/JPUOxIee/DCfFFLuZfSjdREq9f3Xqcy+CNTCu3e+GuNxxE5NMubPpYkYcwfEMU4xNuNZa/1bAYO3oX6WzGipIUcjKITbiTmTR5fD8TgqdzkTm5KkQs4sWkZi9wE1HmuWN7KFU0if5kTX+6wrqE7QIxOpYusLSZhQscrTZ0/UTXzxiKyCsFTxp7sBl3skZMJm17QvBF5KbCnIrEctlFbM4MNiKiHAHPrU7ZzD0vjIvbsiBmu5eKrUOHNYrXIrYbqzAyZCFTpJiZIhibsiFkwxgdY3JM2aAKSUuHG1XYRIM3yjo6jFFEyuCVkEwVonEuvKRI0HYyx5VLdEZJKngjJLUsrbKw+TbZ5MuKVBRHyWtX5Y5WlDFZBqssXZHJLVzm2CWcFLkkKDdmQ2eKzPGkkyplVLbJkLIw2CLgXNrI4GIRUYoWuV8u8rhjF1hUCWlQoTdKZ4qgb0gWcIxJMAInPnHiAysXidmQ1O8lkteHLRnhhckx5xLXkU9sksEaZTC63zeIEhXAVoFlEXI6MQxG2CTDmC0ZJWlmMA6bDUvjMFWc6MUy2CKnHKzgBKZU8z70jFqO91i8GHpjSNmiqmQyg7gqPRSC5tvmVAVVOlVSFqwBJ7ByuQgVu4lhsQU4kDsmVssNxma8i3vpZ8wGK5mnFmusKTK8fn1EVwV/T6/WrBYbrl+/weLaGXH2WB/JuYj8rMkshhFvErnWPWcyy27CmcTxdklvB3priRmslFgWw8jqmRsYF7n2fIl1de2UNHtOx4GssFxsObp+k2c3C6boWQePN5mnhw1H/URWoXOxSiMdITpuTkOte54pWc6ixaeufM2pQlIRZdlNLLsJazIfODveiwOLdLDIB4UijOy7QEpmL4MFQ85KSpaUzD5/Fz7gTaLPkeWwRWxiGntyMhyr0B9tuC6Zvp+4uV2RtIgqvTF7WeF66tlGVwWlYEzGdgHjMrafiXEg1raeZsdmu6DvAn0/0dvEwiV8LnJaEeWpxYajYcscPXM8/wiZk6OzicySF6aOxXrB0mWefuoG/izy2+ujIklcblmsZ4YqcOxN6VOW3YT3gdNp4DQ65uiYpr70z8lyfZh59toN3vTSM8zZ8Ew/YSWz8BGDsg6eTXIYevpgeXFyLPKSiTOcOo79zPFyXWWOeS8Npgo2t2dLuljqtquyWShiUADfBZaLLWbKOBeJ0bHwDmt2UtSE30kmJROzRUTpqtTS1DqSstnLK/f9IcqcHEqVGyNFDFxjtCZjUOYq8k1q6jnME/mdR0QsZQrnR1O+p3yOiKCq3/pQA2s0Go1Go3HPvNIIh2+5y3sKfPZ9jKXRaDQajUbjh4AR+Dna9M1Go9FoNB5r7nrDQVXf/noF0mg0Go1GowF8uKr+nocdRONR527De57AoT9XHsq/G11qKNMFLOW+3W5MYz7YZg+2wZ1d8vku771SNPcwMloMaAYxqO6mOuxiu3jtWlO3iPSoTqyn97Ke3stvyN/jQ/+HCfjHCD+FkjCyRAkYc8RR92GEvGU7v38f5S59JQKCNddI+Yzbp1xcdi33OsVCEPH1+i6mvZsisuPyPBcErecsv8dL93v1MT5odtNgLpsOdLf3Lu53mF/mwrtS6hOG8xl5l+X3q2G3jOrF+nAew2X1Xvfnu1+LLl2M//K8OIxH73rNu3b+Svf5D/sSw1WOu1LvISJLEflPROQ76t+fICJfcJVjG41Go9FoNO6BHxWRz3nYQTQajUaj0XjtXFUa+V3Au4G31b9/Hfh+4IcfRFCNRqPRaDTesPw94H8TEQME6qMoVT15uGE1Gg+Tqz6NvfgU9eLPO2277O+rvvfK0dzTzq9wkODqk9qMonh7zJ/5iC/na7/s+xEf+dm/8zb+5Z/+B8T0wv7pf9Y1YFE949b4nlc4sZLyZSvxXhbYvT4lV1TnK6Zz+egOvcPvdzvno8XdZKdXFaFeLLP08nfvetmvJU9257qYxnkMDyfH7zyC4urxXCXv79SX3PksV73h8HGq+qUi8kcAVHUrr6M9UkRxx2vstW2RaPnIMgtPL9cs10d44wGIY0eePP7aFj9t6F6cmMcebyO2CtSyClHNXmi4E4PNY09SOR8kki1ilG454rqA8ZE0exY+0NlM7wLL1ZpuOe6lYlO2hNnjpg5xCfOUIv0Z+kFDiI4x2Sqfo4rG0l4q5kxicJGT1Rkh7cRgsk97F3vIlm30RbRoIiEb5mQYU9nPcC5CA4hZGJNhzpa5CiNFwIrBmSJFHJOgwLiTAQ4T9jRj5LziWJOxJuNsZiWBlcsMNnPNB6IT5mQZcpE2LlzmyJUKuBNl+p38rEr2fBUMZmCwiaWNZFvkjtZkVq7EcuwS1/sJH3yReQosnWGwysoV2aavx7jgmbJw5BLHPnDSjfR1HyNKykWot7SJo27mqCvSuVDLfeUCnU2EbLEycBotBnimn4pwrp/wJhF1xbGLXO+3fMjJTaxRfmccWEdPZ+HpbkbrtS1tYuFikUZmgzUOb0oeBJvpreHYl/JbR8s6GrJCUvAGzAwLa8mqOBG8MSys4VoHK6csrDJnYUyCHz03ZoNkwSH0YvBGGLDkpCiGXgydMXgVxizk2jkYKRLJfZsDnCgLF1m5wLKb6I+2UEWInU0YEzh++ia+n5k2A/3ZhIgSk8WazLWTW1iXWK+XdDbhDQw2slpsWC62LJ86JSfD9nSF7wLr9ZJ1dEWgeny2rysGcJKrbHGmd7FKPiFY9iLTxXJLd72k+dTRKQDDtVNefP+b2cbSRwyLkf6pU45PV1zfLjibe7xJfOjJTVbLDSG6IpM1GdUi8Bu2S6wonVkyGM+cPavTFVaK2HTXh/RdYLVcM88dVnJtY5nBzywXW2IVEg79xHKxZZ47QvTEaIvY1BQZoXMRXyWBCz+TbBHdDv2M9ZEwd+QshM1Q+qjViF9MXHvpOuvQ7dtZKaNMyLb2JZC1SBBzdGhS3BHk2ROyLduzJSVHCMpyseWkG4lVPJtrnfiQ6y+yOlozbgdiLGJNVSFGR2fLF7uXJsf7N0dc7yJPv/mDHK1PeXF9zOnUs7p2yuLWMQu3RIS9VHUxjNguMEZHyrLPfxHFm8Sym/iQN/82H/nCc6xDx5uPb+6lv0aUzdSzDl2pn8ZzY/A8f3adYGZO9IhnVy/x7HPPsz49YuUDY3JYyRhb+o9pu9j3f8cnp2zHAYDFcsuw2NKtRpyLdNsB5yNiMtv1ElelkL0Lexmkt5FY+9NDeWjfzaWcbSLnUq7j1AOlXMbg959Vqo6UDarCFF0RBCe3byNWzL7PfgL5FuAzgZ9T1Uftm3Kj0Wg0Go174Ko3HGYRWVBvXYjIxwHTA4uq0Wg0Go3GG5V/Avx8u9nQaLxWLvMCHPKoN7Fd3Odxigwsu7fgTM/SXOdj8yfy7358YB0nPv4v/m4+sHk38H8dOCAO2W171JwGhzyqcTUar56r3nD4BuDHgI8Qke8FPgv4ygcVVKPRaDQajTcsvwX8pIj8KAcPN9qymI1Go9FoPH5c6YaDqv4fIvIzwGdQbgt+rao+/0AjazQajUaj8Ubkn9VXV1+NRqPRaDQeU646wgFgAF6qx7xVRFDVv/tKB4mIBd4F/IaqfoGIfAzwfcDTwM8A/5Zebk9pNBqNRqPxBkNVv/Fhx9BoPDk8ytMH7kZ1rbHz4fR4dw1rOp72H0XSwIfoh/PnPvV5/uovfQQ/sPkRtvNv7pfVvH9LDzYajdfKlW44iMifB74U+AVuV6ZD+OL6AAAgAElEQVS+4g0H4GuBXwJ2duk/D/xFVf0+Efl24I8D/93dEjA2455dI9ccGMEtRzTcHrqqMM8dcb2g62/gTtZ0iwlzK+/FizsZ18uuzyjrzYpNtGSK6DAER5o8vp8xPiI2EYLbC8BUhZQNORni1HEaHX02bNZLVIVr2w7z7AxOSZuBm+sjbs4dIZdYvI0M/UQIHmcS1ijLfqLvwj4ug94muwRIucgIjSjenosdhSJUdEZxUo5NFFHZ7pUPBJReDL4aMncfQ1MWptmzOj7D2oxIOW+q15rEFEGfSyxcojeZhYukLDhROi2CSm+UzmQGW44dk8GaIrKDItrbXVfKhs5kuipeS7nEvHKZkIWViyxdQBVCNhhRFtYVaaBNeJNxJmN3YrZkWdjEwgVW/cSyKyJD5yJzctyYexYusPCB3gditpz4kucn3Yi3mZRL3EY6rCgn3czKzxz3W6xk1tGzcoGnlhtOjk/Zzj0rF1k5hzPKys+lDmXDwkV6k+hdxCa7F4FaUTLQJcsyGeYsnHjDrWBIVe5nBcCysIJiyQorZ1g5uN5lnu4SJz4QsmGbLN44rDhkLuU8GMPSCTYp4EiqdMawcqbYnQMkLXFYkSIurFVk99OK4myR3BkfCesF43YgZMuRD/RHG9zRFuMjxmY0CzkbjMksT85KvUuGziasFLlj3wX6oYySTtGx3ZQ019slYyqiQNfPL2uvO5mjlVxkq0aZjVQJat6nCbAYRkSUNPbcunXMWeiYM1gXEZcxNtN1MwsXsKb83vUz1iZUDSLl3F1X4nAm0dnIyTxwGk84OV1ghH1fUISLgvOR7TggUgSLvUkM/cTq+IycSzvqfMB3gRgdIhkRg1Y5oKqQkiVlwZgqWjW5CFazEMee07MVIsrZS9eKZLKfGU7WRbp4mvf57CUzTgPr0DEmyyYZxgSb7YLx1grrEu5oy7xeMFf5YE6GaS4iy66bMaK4g3KwkhkWI84HfLIYk8nZEKqU09nEys+sXObYWXoTsV2glyLAnKPFL0e8i3Q2MaedADFjbSLNnjE5MjAny2ZcICinoeOZbMpngcn4Wh67OhLzuVxysInBWhYWjoxnoUt6HMfDluGpsyL1NBlvMtYo3kSMyYxTh0ipC8PxmuPNghA8XT/jFxNuMWK3PT4bvC/5vhNNehsZ/Lz/rBFRhn5imovEck5FRqqTYE0mmEyIjqSGce5IatgGv78GKGLhlEu7HKNjypZNsoxVpGlqn/04/jPiTojIt6nqvyciP8Ql/0JS1S98CGE1Go1Go9F4DVx1hMMXAZ+kqvckihSRDwc+H/jPga+rK1t8NvBH6y7fDfwZXuGGQ6PRaDQajSee76k//8JDjaLReGJ4nG5J3nkkhpgFbx/+MF4MX/iWyNs/4Zd588e/jxfeP/L7fmzmpc2P1mUyK5cKIw/P8TjlS6Px+GNeeRcA3gv4V5H+twH/IeejIp4BbqhqrH//OvCWyw4UkT8hIu8SkXc9v7l8ZEKj0Wg0Go0nA1V9d/31U1T1nYcv4FMeZmyNRqPRaDReHVcd4bAB/qGI/B1uN0a/404HiMgXAL+jqu8WkX91t/mSXS+9zaiq3wF8B8CnvalrtyIbjUaj0Xhj8BXAX7qw7Ssv2dZ4w/Ly5RJf/hXz4ldH4fw52+5Bljn4/fCYqywjead9Lkvnql9j77T/Vb8+24PfM2AQpDoNQPBlwq140IxSppSqhpcndVvelHR070XYvXcx/86fY+72FyyIu7D/eTlYsyLlNc5eQ7VMM3RmwTPdx/JJ+RP4orcon/vJP0vX/wNeeOEZ/vuf+12848d+mZheoDy3PMybV8rnx+WfE3erW4c8LtfzevBKefZ65NVVyu31LrOr1iW4PLb744C56g2HH6yve+GzgC8Ukc+jCCdPKCMenhIRV0c5fDjwm/eYbqPRaDQajScMEfkjlCmXHyMih985joEXHk5UjUaj0Wg0XgtXXRbzu+81YVX9euDrAeoIh39fVb9MRL4f+BLKShVfAfztV0pLbEKeWcFqVTbML4Eo3kaSCnMCa2DaLphOVywjyCLRHW/obhzjXcTOGWsyWm/SmCpSNCZjXOR0u2DMRd43ZeFss2R786iI1UyGZJjHvsjhgCk6pu0CzYbtZsFLs2NhM6frFapCuHGEfep58tqzffGEG9slp9EQ8/mdJmNylcLpXkxnTCryOCjiOZNwNhGzve2+MhSBm5UiYzRSRISGIhzkYF9vlJQNClWKWWSBIcOcIWbwAnM2rLdLnko3ESl5FbNhyoYpFulZyKaIzapMzkrGO4UIZEtnM77G1JtMyIbxkjLtTSaqoKJVTJdIWuSSopmVS6yjpbNFDjen8nsR8bGXUFqTOe4mBGXOhqzCYCPepJKnLhKjK2JAG1lUWZ0ziZgsIRm8SRhROpeK1M8mBhuZrd3ftxfRGl/m2M/7NESUkOxt15ZVcLVse5OqMDEDdl92nU23CQeNQGcSquf3/jurgGWwChTh37UOFlY5dpmVixz5wJxLXCfJMCULWJIqXoSTDsYkdNEyZ8UKrBxofdIzJiVpvf9pDF4Ea8rfIiWOndBPTGY8XXG6XnE69fQuICbjliMimRwci9WW7XqBmCoI9ZF+mBhsoKv1PEbLNPaY01xkkZslIsqL6xWn0bKZe3J0+3yHIgydk8PngCIYithSDvKzP9qQJ0/YDkUu6RLrl064tVkxJrtv+3nyTGPPNPXMyWJzEc4eShutTZgquBRRnE0su5mswtNd5Nj6KvVkLwiNyaIqxOhwkpnF0LtI30+snrlR6kp0e0FlipYQz7vgcv4ijyzixFIfi5Cy/EzBsZ4GeheYp55xO9DNM9bHfb+mWkSDGWE9DkzJMte+LWbldFywuXXEYrUlni2IsydpEcJmFaadAHKzYk7n8YVsyAZyNqxPjwjBE6LjbLtkCr7EHR3r0HEai/wUYDpb7qW13mb88Ya+n3A23SYGdS4Sgt/3W0kNZ9MAwI2542zqufn8dX7z7JgxWawonY0kNczJErIlq7COjlvBMiYImokSQUtdcsNcRKBVPKp1e86GzbgofYVLGJ/wXUDVYH0oUlQf0WSJs0dzEYuenq14cX3M2dwRs2WKrrQXowx+5nQcUKTUM1H6Ktm1RplrfZmTJSNso6O3id5GRKDTuD92d42p9r+3PyO8l6cXjzz/N/BbwLPAtxxsPwV+9qFE1Gg0Go1G4zVx1VUqPosid/yoeowAqqof+yrO+aeB7xORbwL+P+A7X0UajUaj0Wg0niBU9X3A+4DPvN9pi8ifAv5tytjQnwO+CngzD3WZ7sd1ucJHgcvy7ZWmOygvXyrxTnLBq5TL/drnKvtfNZ2MYKtA8WAaRJUolikU5rYpFIKUKRaXYjm/tWlrjQ2I9KgGRDyCIeu27uP30y6M9GSdEPEYcfvpEuWnY6dzE3FYc4wzC3LdlvLM8/Ov8Dy/wjvfu+Udv7KmeOsN8JPcXm5PYht6Eq/pYfB65+OjWG73EtPuM+lwatf9uaarTqn4TuBPAe/mVSxsq6o/SekhUNX3Ap9+r2k0Go1Go9Fo3Csi8hbgHcBbVXUrIn8D+MPA53GPy3Q3Go1Go9G4N656w+Gmqv7oA42k0Wg0Go1G48HggIWIBGBJmbpxn5fpvhd53Svtcy9pXRwpcZWRE/cqM3xUOLy2w2u4bETDxfcvPrmTO/w8PPbivnc6753SuRj3nWSXF2WWh5RJVCK+jky4uMBc3qctWER6rCnT0VI+xcoK1YjI+Vd+YzpUIwv/LFM8JdcRD1LlkqoZyPtRCmVURKzHlfeQDshkjVhzzF5SWaWPKc94c0zOERFDyhMiBiNlGqq1K7JGsgas6THiETFM4SV6f52skc6sMOJw8iyb8DyqkaxTjaHkjTFLBEPKZ5w/E71TGZTrM1LyJ+v6kvx+Pbhb+3s10+Qet3YMd++nrtqH3antw+ULMR4+M38tI8xe6dyXxyB1fyVetvN9YhfT4bnvJMm92/EXfz/kdqHs5QLZ27nqDYefEJFvBv4Wt69S8TNXPP61IRR/Q9dBjOAsefK8tDniLFrGLDiFceoIY09ed5hrM3aYMDbjfaBzkc5GnC1uglzna3sfcF1gip45CVMSvBjW08D65jHLow1iMnH2bLYLQjKkLIyp/D1OHePUs45l+zZ0+DkyvnSCW43E9cDpi9e4OQ3cmg3OgJMy17rvQp2/r5ha6WN0xDoX2UnG2YRzEVc9AabOabeS6X1g4SKDzQQVvCiDzeWjRwXyuevAm0xSYbBKZwxWBFfr0a65hSxsph6Azges0X1aGdn7JowoQ/UcrPyMsxlnMmdzx9IW50XxKJgy9z4belP2Sdkw2MTKBXKdn3zkJwZXPA2zWDqrHLvSGFc+0LvINnq8yXjJ9DaztJmlC1hRToYtqsImdAAcdTPLroyKNfWcxpS8XPnAys90LrKeBrbR1zwqPoqopYEWd0Sq86whZUOqjoiFC7UeCSk5xuCZk2XKggj7+fDWaM2b8w5Oqt+iq+XRqTBlg6vlutDiJxhs5sgHDD0Ll3HiGROcdJnBKE91obhFKLEZYGkzz/RgxO7L+siV82xr3U4K17wSFbwRNlEItX+Ys7JwgpXiR9ix853kZDm9dcytccmmXneaOjQZxGVStKRomWod8j7g+5luOTL4QF/zOSZL3CxJybHZLtiGDiPKWejZRGFOjlj9HUN1XezqnYgiNW+Lv6TU+4UP+NWW8cUTtqcrUnK4LnB2esRm7hmTZcpKzpbp1oqzsxWbuTocjGEz95jQkbVc+M75ATDPHVP0xGQxoixc5Nh7BlvjqR6SkBwpWnL1gJS6OHH89E0Wb/kgtg/MU4dzkW5Z6uyhO8KYjLUR5+LebbDzMaTqdsjJMEWPiBKjZQ4dITpsPWbpZwabyMBgIyFZogohl1emuEhC8HRxJgdHnDpCNlhRUnSlrqthM/VkBF/r75QNRoUYSt83zZ45OU7HgTk7VGGMjtPouRUMIUembBjXCxZHG4yU8vcna5ZHa1Y3x31/0NlEP0ysz1b7epeyYY6l31tHyyZ0vHTzGh+cOtbRYs2S3mSmnd+i5tWN4LgxG7YJJk23fV6Kj/jFhLO5OiASq37cu1iMZGLwaBb6YcS5SH+8wS1GxCjT2LPZLrAmk7Ph1nbJ85vSHrIK2+q/6GzCzx235r64arQ4dobqnHAmMyVbXRvlY3rOpu5L6a9zSWtMjqTCmCxBhTkZfHWk7P6Z8SQhIhb4blX98vuVpqr+hoj8BeDXgC3w45QRm1dephv4E/crnkaj0Wg03khc9YbDv1R//t6DbUp5OtBoNBqNRqPxmlHVJCLPiUh3v3wKInId+DeBjwFuAN8PfO5lp79DTPtlumVnsr2U+3n7517Surjvg3ALPCroFX6/23GXHXO39+7lvJelc9X37jZbufoX9s3hzt4JJaKayGlzfrQmIN926pTL08izdHqX80Li9vezblFNty21Wc6xexZZ0o3pZvE5pDIiQw6X66zHxVxHF2gmATPP790Q2/kDoJGpXlU9Oy/Pv0TOl13D3fP54Y1s2HG3+nqnJ+eHI2zuNJLmceKV8uCqx182ggkuX+72Xs9xlXPvuKzMbo/h9Smtw/Zykcu2vZqoDttiOvh557SuukrF219FNI1Go9FoNBr3yq8CP12Xxtz/y0BVv/VVpvevA/9MVT8IICJ/C3gbbZnuRqPRaDQeOFcd4YCIfD7wycCw26aq/9mDCKrRaDQajcYblt+sLwMc34f0fg34DBFZUqZU/GvAu4Cf4B6X6W40Go1Go3FvXHVZzG+nSJbeDvw1ygf033+AcTUajUaj0XgDoqrfCCAiK9XXPvZZVf9fEfmblKUvI2VJ7u8A/nfaMt2NJ46XTzt4OQmQe5fX6cGPVxiJrcwHv98lvMO3Xs9VaR9prjLd4HGeTnG/eRTy5FErjwcZz72nfdURDm9T1d8jIj+rqt8oIt9CEUi+fuQM2w3MM/pCYvM7T3M2F3nYmGDlinAxzJ54a0l3bcb0gZwM81xkgsYUMaAIeJPoXaAfJqxLVZQmZQaQKCFbtuOAdUVaN08dtzYrNqFjzIY5WdbjQMqGmCxjKu7RMXgG7wnbgemFa0xnyyJYy4YpF/ndDmMSzp5/EKRsCNExJ0txABdRo3eREIpAzJoiqQNwJrF0gc4ovgodvcmEbMiiGDmfT7STFXpRegu9MYhAPqgzO+lbSraIKqssrkjNdP+CIjXrbGLwASNKTIaM0FXZnTcZS5GyraOjM0XSZqtssq9SSCuZwcX9NSU1eCKdTSy1COtitiWubMAUoeFgSznuiFWq6Wt6zibm6AjBM4aOIU7M0eFrns/RcWvquTH3HPuAFWEbPFNyjMmjCnOybJPFVxmlaonvXOK3RER5frviRnCsYwnoNHhclQm6ZLBSJHxzKjLHUOvaNjrGZNlGW4R9Ve6nFKFjzKWMtIoMRSBlIYlyMzicnMcoooyp7GdQgp5nTil3IQhEra8MIZdrellT0zobTg8kpSaTg+N0veJs7jkLnqXtGU9X2GEiR8et569zenbMjfUKazIhOp5SoRumKh6FkC1n2yVzdHTbUgfG0JGycBo8cy7XFKaOvkpBbZWqGrl97pkBnChGSlsQm9jeOmKzXjJOPTkLt86O2EbPmAwhQ4yWeOuI528+xek08NI0YEVZuLAXNRqUKLqXhG7mnpBcqYNqiNnU9krpM/blo+heOlokjp2LuGFChogdyhzXGB1ilH61wZ0tiVUeaACp7Xs3Mzbl8zmyqoJWae0UPePUczYucFWsCbDoZhYuMGWDNcpm7thGxyYZ5lzKdo6Wae7owsy87Rm3A2OyeJOZp65cYyoizW1wtQ6WclGT2Y49MVq2ocg051zyRhU2ybGOjinBJke20XF26xjnEiFZ5mTBZtww72WZ8eAaz9Yrxtr/baKv4lnLrWA5DR0fPDvhpdmxicLKeXpT2g2Ueq0qnAbDOgqbqEwEJkbWzKyngTx5+qdOsVLkwSJK383EZNnMParCOHUspw7Xz3g/4YYZ4yPTjWNu3rzGS2dHWJPp14EPbo74nXFByCWGIiGtolYcp8GTqjDSyrmEV3KpR0nL54YRJdR8CMYgCppLfxOyKbLI+hkyJsNAxgBjMpe24ccdEflMyj/+j4CPFJF/AfhqVf13Xm2aqvoNwDdc2NyW6W40Go1G4wFz2Zohl7GtPzci8mFAoMiXGo1Go9FoNO4n3wb8QeAFAFX9R8Dvf6gRNRqPPXLwspR/Ahxuu5/ngJeneb/O8aRwp/w4LyPBUcrKcntZ3c8ye9w5rNOXvV6vfNrF8KiU02Vx3O11lfRePVcd4fDDIvIU8M2UIYlKmVrRaDQajUajcV9R1feL3PYF524a/0aj0Wg0Go8oV12l4s/WX/9XEflhYFDVmw8urEaj0Wg0Gm9Q3i8ibwNURDrgHcAvPeSYGo3HhN2Nut0ygaYuY+kw0mPNAgBrOkJaA5mUt6gGbl82zxz8fXFAdD7Ydn7My5a/1Iyi5fy7bYBqOjhGblsw8OK+5YDzdMQsMNKR84iSUC2LZ8runzTi6jnGl+WLiK/vzbx8Wcm7LTN5p/d217vLg8OlKw//Pty2w3D7fdQ6PRNb8yPXo82F7bvzHeb/xdgu1oHLODzGcrHsRWwtp8vSPzzP/ZrXdxjDZddz2bWYg/pzmCevxCuV/cWlRw/Pe9n2XVu5bNnJu8VwmOYrxXp4Lnh5uRymd9h2X4mX59nFNnmnbS/nzs8F7mWVircBH707RkRQ1f/xqsc3Go1Go9FoXIGvAf4S8Bbg14EfB/7kQ42o0Wg0Go3Gq+Kqq1R8D/BxwD/k/PaFAq/PDQcFTs9gTpCUdDYwbxachY45n9/RmaMv0sj1Ar+9VQRryRaxWXR4W+SERorM0PtAtxzBZFKW2+7jpixFOLgdSLEIJNdTzzp6spb3izTNVYlgCXNOjjk65qnDni2ZNwPT1O/FZl6gs+d3nZxLWMlkhJgt89wRssXVGJ2LJc5kydniQ6Q3aS9GXPrAYDNzFkTAVfFdVkFFz+9x6vn17e+RVWlkVogqBIVtzUNjMs6mS+5pCznbKl0rMRuUORUBouFcNOhNKsLCKpjc3W/zJuNNIqtgTZFNajaMyRfpmmQMupd3zsmySUWmabIhaUknJkNUwyJ0jNGxSa7K2XIReQaPtz2buaMbF4TkEIoMcIqOdfRso8NVoZuqsEluH+e6yvZ2hGwJ2WBQkhqcyczJcit41rFI+WwS1tGxtAkRZRILEaIaxuT28rcxWcZk2STDmAUrUoR+uYj0RlFEimRyykWIN2fBSKmhKRYRXfawSQYnylhjjSqEfC41pF5PUpgSdKa8P6eSbtIiXjS1TlipP02R6glKVmFeD4yhYx08m1gkfme3jjEuFlnf2TEvnh7z4naJNZkpekSUa0/d3EtLYza8tFkRsqUzkcFF1qFDteT3nGEdOs7WRwx+pjcZtWkvdMzZsqvVUmO0oliTiduB9dmKs82yiB6j49a4ZE6WKQtJlWm7YJo9L2xWnIaOF6aOzmaeiY7eFdFjrs8RUjaE5MhVHkmtc7vf9+cW3QtMUzJIbbtJFW8jxmaIQg5Vahsd/XLLcLLGugQTe4Gi1v4sqUBtXyJaZKHZkGp/oyrEXd+WilB14WeMlLbmajuYsyPV/mkniE1qGKeevptZLEsfOVfpakqWOVrm7CAVCaSTUv7bZAkqbKdh36ekGq+p0lNTtxuBiLJJhtPNir6f9rEC2C5gTN7LYnd91um42KczJcu8E/RGYUyWF8YFN+ZaFlnoq2RT6zGH99YVJZFIEphk5nQciJuBxZufx9mENYqzib6bGaeBmA3bUPqK5XbLyXKkW22xyxGNhunWitPtgtNpIKnQ28iNuWNTxY27PDxkJ4rc5dGOXa+yE0bu6lTWWs5138PnJYdS0t17yqPnxb4fqOrzwJc97DgajUaj0Wi8dq46wuH3Am9VfRJ92I1Go9FoNB42IvJXuMs9FFV9x+sYTuOR5nAI9GXD1+9X2q8lDa6QzmXD7C8OhT6fEnFORqTHiEPEEeLzZTqDGDr3LClPpHyK4PHuGs/1n8j1/BzX9JhAZJLAx7qneG+8wUvmg5zmD3Jr+jVSOt1PhTg/X13BSRZknYCMkSOybvfbRDyqE4JHxJ2/xxaDx5juPPI8I1L2EzF4e4wRjzM9MU8cueeIOnFN3sQtfod1+CDj/JuUKQaK5rODHNoNNbfo7pazJs6FmLcPRS/TRu40zeAqS1EeltlhWR3WxTst0XhZGi8fBn8+bN2cTy+B/fYytP3l01kuP9dVr/PiUPh027SXO3M//1l4t/NdlqdSt+gleXLxcemdpmvsyutOZXWnsjxM//DRwK5OXPxpb/vbyJKsm0vSvYyLMdwpnw7L/LIYLsZ3GP/t2y+bunP7tJWX91GvNIXjqpNdfh540xX3bTQajUaj0bhX3gW8GxiATwP+SX19Ck0a2Wg0Go3GY8ldRziIyA9RbpkcA78oIn8fmHbvq+oXPtjwGo1Go9FovBFQ1e8GEJGvBN6u5XEkIvLtFI9Do1HRO/x+v9N+0Glc3O+yp4S5PL3ViXOBoKC6JYnbyxGVxMJ/GB/a/W5ejL/K6bQGMTzTfRyOnhfkAzwvv8mt+AGsOH55XDOHl0Dqk3+NZZTAbjBzaX77p+yZ7V7emPSsbNN1GXVQ90Xg/2fv3WItS9LErO//I9Zae59LZlZ1T/f0zBi3x4wBy3jGaDAWyDaMeRjxYlvCgISQMSP8ADJGCHyT0PCAsOEByw9gZNmyRghhgy/YBoGM7LEACfkCA7bHgw1uWTM9dDfVVZWZ5+yz1yXi/3mIWHvvPHXyUlWZlZnV8bWy9173iFgRcXat9ccXbtOt/Sey1e1uVQapZT9Rsu0O2xznZv45cOMD+Zl6ylCjLtIzyva2QO/JAXZPX/dJeNab5qe9Eb9rv49GFRw/5bDX7fN9vJR/ngPTj2X40Vw+qz6cHvFJy+dpz7/zC32a7z7hdV+E2/XzNK13rXvW+mft+7x1T/K8IRV/Fvgy8D/fWv9rgZ9/7tkbjUaj0Wg0Ph7fQ3nR8UFdvqjrGo1Go9FovGU874HDrwd+j7v/9dOVIrIDfhz4I68qYU8i+IcJz4rPkfn9+zx+eI9HS8dcH6r0Wp7o5BxYbjb0V1vS9RnL3DEtHckCyUKVi/lBitidjXgqIrpOnF6hD2VEUMqBqcrnrvdn7FPHmEN5pubKzdwz5yJ1W4VsY45FHDkNZXm/4WYe2KfIYlR5XpGDzXN/kKa5C0sORA1kK0LAXhN9t9D1S7mGBaa546Kf6ENmM0wM41KkjFqeendqB+kaQBSnkyJWW9dlL2JAKHJAr/uZl/Tvxw1n2/1B1JdNWUxL/lMk1eXZHPblPFdLz+OlY1AjiBPV6BBiXA7X7kNmMa3lJUxVdnc9D2QTrpeeMQcmKymdc+B6LuuuUmSpgroxK2NWdqljMqXTIvN8PPecx1SleJGbpQg4d0tfpHepq/lXdkvP47lnl4qYsVNjlyKT6WEk0uMlsk96EC8Odvw+58A2JmZTblKR2l0tJV/XS6lnfb0XOQiLKVPN2z4p0DGZsK95MS/3YrHyciGI1npSBaAU4eP6pmHKQqcQVdklJQpMVs4xVhmk1bFp7kc5aPZyjaWKKL1uFxFEnCgwBGpbcDoxtIpWp3HDnMv9z17kmI+vLuiHqUgj91seTRver1LBxQJRMzFkrJbrYoExRQxhlMiUU6kHLoxZmTLsU+Rqv2XbzQQxghRR45Q63IU5lzbitR4HcbqQmXdbxqm0t8fjlnHpDm12n5XRMtPccbPfsksdD5eOD+bAJihXS0/UfJTyhSKAXHIsQlmXUq9yPKSzTDZWRK1BTqYFE2foFvZLj4qTxp58vWXZbdmPG27GLc8wDM0AACAASURBVCEYw9lI38/sb7alXwhGiKW8SvkpS9YqZFTchWkcmHLEyUypY8mKI8wpkHKgj+kgJwxipe5TJJSLVZGiaxE4Lh3TuGGa+0O9TrkII/dLrCJbBbVyT5ISRNmf9FsrnWYUZfHS/lVgITHbhv3cM00D+9SRsuJTR+jS4dhQJZsqRT7rLnTqJBfmVESrYy55mHMg+3FUahAnUJ6tr+JFXQWeDkmOT92TBabrLWda6ksQI6gxbCaud+dF1mha6s244dKFMJS3cnkcGPdblhSrhDQchLaLSam/pgy1z0wuxNpu9EQI6X4iBaUII9f+cfHjhHLuUsS8lPOsUsxQ26ienONzyu8DfkpEfrIu/1rg33t9yWm8fbzolHOf5tx3TZd3e/u6fNf4/bumujvdS3hySsnuMK7+MMbaFzj0gsqUPuTr+a8QwzldeEDKV7w//12y7VEZKNNIJlQGzBeG7gs4hnv9R0YIiCjuq4R8eWL5kD5R3BPuhkjEPSF1KsuybOg6DSX5ieNVOkSUbNNhn/XYbHuCbslrpITP4KuT4aNl/eRUly/Ky/Z+fFzWMf13Xf+uvv0u1wccx9Q/7w3zy5y+8mXxSaYhvWufu8pLT/aSo9/jTn/DJ+FpbfruNBx52rSfL5OX9dtgLdvb/dgnO//zHjh89fbDBgB3/2si8tVPdMVGo9FoNBqNp+Duf1RE/nvgH6P8wvld7v7N15ysRqPRaDQan4DnPXDYPGPb9mUmpNFoNBqNRqPyK4FfXb878OdeY1oabyTPekP5Kt8gPs0f8bS35s+LhLjLbA+Ilj3WyAA3VM8Q9BANUCITEtv+u/nnL3+Un95d8X/mv0i2iT7c44vDD7Cz9xHe5Xr+Bu6JPt5nSh8CMM6PQGKNKDi6FABEBpzlmDsZcNvXdJVZKZCISIflRyUaQ8IxvaLH9+63oiOy6CFaQ2VzMsNEQmSos2XEg7ehbD8tt2NZf7zIhkOCPsExL5MXmZHhRY//rGeTeFm86Kwgz9vn2bNuPP1ML8Pj8axzvS7P8cu813f1dZ/s/M+bpeKvisi/enuliPwYxSTdaDQajUaj8dIQkd8H/Hbgb9V//4aI/N7Xm6pGo9FoNBqfhOdFOPybwJ8WkX+R4wOGHwZ64De+yoSd4llJH5yX70tk2W1JOdDJOidtGfe+n3u2c8+0O6N/dMH48JL9uGFKEfPiZMi+PhU+Pm0er84Z61hhP4xzD+ymDVPKBDUe77eMdYz/YsJkZdz3mAODWh0XL+xTZL90jFOPmTDNPXMu/gE/XNdJFpiXnhDK01tzwayMx+7UigMhGCFkYkyEkEkpMvQLcSr+iVDHPYv4cVSQC9m0eiYEEQ4uBqCO567/DJa6vHgRBuxTLGPM1cimGDBWf8NioXgOcijpBW5SqUKPl8guKZtgiJTx55s6Fj2ZstRx2l7Hwk85slvq2PFUxjw/XjrGrIf7uo6L3qfiOVhcyA6PZgHiYdxzNuUqBa6XwINe2e7PDr6Ert6jZMpYfRsAuxR5OEf2WQlJ6dSRes0gTnbh4ayMGcY6TvsiBlJ9sDdXj4GI83gJXC3weMksFvhgLtc+C1bG82vEgH3SOh79+Hm1CLNxGJeevdTl6yQ86IXZBHPYJXi8OJsgbIMwZYgqZA/sEnRa3A1B4PFcEhlFCFLHl2e4WmDMZTz4ZM4uGUGExZ3By3XOohCrNyJa8UCYC0vquNmdMaXImAOjCaTA4/0Z3aMFd+XDm3PeG7c8WkqdEHE6PaMLmUfThqsUeDz3LKaHertZfSA5sEuBXSoujcfjtngZLLBU/8ZuGkgxcJM6RlPGWjazKXOKPPr2uzy+OeNq2vBh9UgkL23yg0m4spmb/ZaraVuusQQeL6WMP6zOlXXsfFAn22rmLt6XxZXrpeMqBXY5k6z4P9xP2p0Lqn5oP/ulZ//4Au0S+4f3eHh9yfU0EDVzf+oJMaFquAtWr6dqxfFiSrJ1VD+kFLm6vuTxPNBrcRDcLD2p9mmzRc5tZs6huFBy5Hrpavsp9ewmG3MOXE2b4rCJiXEauMmKSmCcBq7nnptcPCS7FBFxrpbAB1MgivNw3CJS6ulN6kim1XEhjDnwqLaHa9lxky65ngfObs54NA2IOHnfg/ihP17dBilFphRZatvap8hNLt9vUrnPUOq5OVylcEiHIdWlALsk7BLsc2aSkcUnMondsuXq0X0ur0twXnGBFKfMzTxwUx0vYTa2+y3jbku3HclTx/j4nMePL3k0bQ7uGIVaZ0t/OyRl0TIffKfFyzCZkKz2w+JEOfZB2QSV0k5Kmzz2PZ2WviPXsli85G/MymylzS5W1vnLfJnx5vDPAD/kddC3iPwE8FPA736tqWo0Go1Go/GxeeYDB3f/FvCPi8g/Bfyyuvq/c/e/+MpT1mg0Go1G4zuVBxxnqbj/OhPy8ngTxW1vM29aWd4eKnG67jan+9QhDJQHlv7EMUoI5wcx4ypvvOi/wlf0B/iRi+/h3/on/gp/32/5e/znv2PHnx9/lrwUEeOUHvJefnwidiwPbafl/To1JSCxCCRtBurUkxKfuP5hmIcbolvclyKFZEGkK8u6RdahGBoxnxBCHZKhR7HjIczcEOmqoDIS9AyzGZeOoBvce0QiOd+Uc/gnmdLy89LePi/5aLzZvNp69rwIBwDc/SeBn3zujo1Go9FoNBqfjt/LcZYKAX4NLbqh0Wg0Go23khd64NBoNBqNRqPxWeDu/6WI/CXgH6U8cPidn49ZKtpbys8Pt6eIu+vePm9azFP0VmQDuGcEKzJHN5BYogkQHu0f8Uj+Dv/XDfynf8rwP+Wo/kk23Rc4676LM32HXrZ8Y/yb3Bu+j+vlW4dpKKFHCJhPDN2XcHIZ/qhbes7wOpDwxj5k0AsWL/Ofm2dUAioRJZB9IfmEoPR6RvLpsE+UgeQTG7lHZsExkk+HYwVlIxfs/TGBEv1gZAIdV/mbDOEeu+U9gg5My7drtES6XWjP4dO2t1f5xvd5575dR543FeF3et/yvGkpX/V0lE+7P7dViZ/FtJhwnLj9REL7hJj2Wcd9XE6v83RR5vOkkY1Go9FoNBqfGSLyG4Ebd/+z7v5ngFFEfsPrTlej0Wg0Go2Pz1sR4eCA54BU+aGETM6R2ZQ+wGAQtMi3cg5YVtLYs4wDqUoNVZxYJYbbbuF8GDk7v6G/d83NB2V4qHmRzFkVSk4pkiwQNTPnep6TdClF8GWA1odCqwANqkiuislyFR6u0saUFTMhBOhiQs0IavRx4ayf6eaBIEa/mRgubshLRCan7+YqtbMik1QjVAnZbEqq105VAhjECeIMmlGcTnrMYTEjuSJVUmgOiSJ+W3Ig5XDIr1chnFW53yrOdBfmKqx8vATGDNmLFE0pAsY+HJ92dZoPZTtW+WCu515MuVoCyYSxiuAAbvIqvJMq5iwCxSEIm7CmI3KVAmMWNqFIB6+XDqPkf85F6raK3gB2SdklZZ8FQejUCYcHe0IyuE4wZVAR+qyocJC0ZZeD3HI0YczOjSVEijgvCGQvMsrsjnu5/mzCmMuTx6tFeDjDbH6of45jDkMu0z5lh2Rwk51dypgHQLhJTqclrfvsdFJEkJ0Ko3l9dl6kcqlKJ3fJyO6MWZnMWdxREdy91NuahrUYOnU6LQJFEWNeehYrwtBsgqmTXRmnAUe4SR27FBmzEsUZc2C39OyXnilHxlwkhIdSFmcTMnMuYshkQq5jQMcUUbGDUK+IJSMiRfZ36BvWupsDHz66x/U0MKXIropiO7Uq2oOJhSl1h/Ot681LPdvUtAVRyOUeQxGgOqvYNLJLwmS5TP9VCWr0ITEMEzHmgwBySh3z1NPvN+x3W66ngX3qmFKHZaU/Hzmbd8xLRwyZfpjJKdCHzFyFhipOkNLepyrdXMWDyRV3WFzRHNjUSrxuX0xre137p+NT9WnpmJeOORd5aqwCw1X+6C7c5NLGrhfh0Qx9EHZLj4gf5JSrQLXUs8CHs/L+lNjpNWOmSiq3XC0dQRzPAY2GuTKnUN4RipOWyE3quMla+zLY1+vP5od2M2evwlpBKffA4CDuvVrgJjmjZ7IkVALUMhqnnmW3Reo7vK6KbPdLf5RSpsh+6bm5PmfYjgDsr895fHPOTeqK1NKUVK/rFAFvOhF/untNU+nfVJxOAC0iyFV4qziGVlFx6YfchT5I2acen+vfpl1SkkEOpT8cs2Cf6I3EG8+Pu/ufXhfc/aGI/Djw37zGNDXeKELxAniqXoDjWzZBarTAs97kwTFCYT1mPQ+H/r1EGZRtq4egRBvoYTsU/0LxG0wfWY8oQS8xn1HpyXZ1koTiRShTXUbAiOEcQXnQ/QIGueD99DWyL7gb97rv4V2+wq/ov8IuOX/V/ibf2P2vgGF2w7jAyPtc8XMIimrPh/u/g2p/mPZynd7ScVJ+iBDYwwuW2Wm5PW26z0/P1fN3+Qz4rKZW/ayv/XnkdU9L+bT79Tqnxlyv/XGnUP243HWdj9IiHBqNRqPRaLxJ3PXb5K14QdJoNBqNRuNJ2gOHRqPRaDQabxJ/TUT+YxH5xSLy/SLy+zlOzd1oNBqNRuMtor0xaDQajUaj8Sbx24B/F/jjlJjtPw/86681RY03jHwYtrAuH9Z/rPP4rWPKeU7PvW5zn/nIypNFt48OBPD6fymXGV7tiYPLsAS3a4QAEhHpmJcPAfjW8n4dZgEiEZWOR8vXeS/9NH97D7jVoR4D7iOqZwzxHZa8wz3VNCfMRzxPByml+00ZAoKAdKzvHvUwjWU5d0mpnwxRKUNNjsNM1nycyujuEvWtKM8W17VhBI3G55X2wKHRaDQajcYbg7vvgN/1utPRaDQajUbj0/N2PHBwwZPiKDb3TI/PudpvyS7MucjCsoGZsqR4kLTtri54vD/jeh4QcYaYipgtZLabkc35DeF8ZJk7sq9iOJhNmHMgmxDU2caliMJcq+Cwig5dqyQvsEtOqMLA3dJxM27Z9DNLikwpVvmhsxgoym7pGZceVacPCQ9C1JKui9Sh15eIOF2XiJuZEDOhS/T7DSJ+kMIBxCrWM+cgrDwlyvpkGoI6jjO5sc+GV+HPbEKnRWy4pEhKkZQDVstkMS2iPVN2KTBnqVLGIsG8SsKYy74qQpDy/HqTIqmKIUUgijFZkc3d5ECqAsrlRIgGPCFCm6sscq7n3yVjCMomKNmKqHJXr38ZlX0t7yDOUkWYkylzPj55n6xca7FV1ljSrFUmNxuM2ZkybEKRts1ZGE1KXUMYQhEdjlkYszGR6CwwWyBkOcjdsnmRHR72BSif+2yM2RARsjvm5Z3BbELQgFCElLMZe8v1fgZGs4PUcDbHFPbZa94MBeasBFnLrpzDgMnK98UNNVjcEffDuXoTopZ3EEGMTjMxZKY5HISZiwvRijwye5Hozabsk5JM0ACpCgtzlfGtOqq1jpoJ10vHTQoEdVKt0lqFhEFLPqyKWUt7L3Vyo8ZelC7AJhibvrx52sTEbPFQezYhM5nW+lhkq9nkIBmcMkiAZFIkjQBVTpurQHY0xV2YrNTRIi8sotggTlCnD5nNMHH57iPyHFmWWEShKTLPPeNuy+7mjOtlYDFlv/TkuSO+85jN+Z6zcUDViMNMnwJncSGZ0mmu7dboYuLxzXmRCJ70R9QyzSbMOR6khCK1zEyqvNHJ+EHcOudIroLYxeQgqLTaXt2FOQu7JFwl4SY7IsJNDgRxUu0PvPaJy8m1JjeylDdliwVu5p4xK5tguAnSJbbDyHbuiWr0IVdBKIe+rLSSVVpbBa25yFGDlDY6WbkPVutl6asgu5Mx7OQtWjY9SIQvz3ecPX7App8PZef1fi8Wiuxz6VjGoeRh7plSx5hD/Vsgx78FtT9Y5Y5apbmn67ILoiD1+yqHNYqsdf2b0uEsLnQu5FoHV2FkkaqW78H9sO3ziIj8EuDfBr7Kye8Ud/+R15WmF+NZUyR+0nO9yPnumnbxRY55kXO/aZzm7fb3p/E0yeFd+8CT4kkoLTUcpJKrCNJ9lQcr+MmUjVX+eBBHnuwjMpxccQGUoFtiOC/r3HA3zBdEFHcjhi0p79l277Kbv0HQDdlGVHvMUxVVFmnktBiqPV28RCUyLu8Twz3MZkT0GBVR86M1PY6hEoHNIc/udkiDr32pG6rb+kuJw/nKHQi3vi9InfKyrDeoy0dOIh2qjPPJCIrPahrBz5pXOeVm48jt9v5Zl/mz+pvvLN6OBw6NRqPRaDS+U/ivgf8M+MO8Ps13o9FoNBqNl0B74NBoNBqNRuNNIrn7H3zdifj4vMy3Vh/nXLf3fZFj39Y3bP4C35913LP2W7d91APhpCe31R2OroeTiBHPT1zH/eg2cB+fjJDAyLY7RBG4L4fpN5WIeWJOM7jxePwaJdqiw1nIPtXrrxP0Gu4T2Ray7T6630mmSnSFYWtkhijZF55wLKzTf972Ofh0+P7EetLRE1HPv0ZxHFl4psPBj+f8fPN5z9+bwusu59d9/du8vsiaNktFo9FoNBqNN4k/JyL/moh8RUTeXf+97kQ1Go1Go9H4+LQIh0aj0Wg0Gm8Sv7l+/jsn6xz4/teQlkaj0Wg0Gp+Ct+aBg+cAWuWHwdh2M6kKtMxXQZriVPnXEshZSVYkX1AkaX1MnPUTm2FiOBvR7YyoFVmgHyWCUM4XyFRf2UFc5xSRma6fcgwtWyVu2RQzIagRtYTcrecNVfKYcsBMuH95hZmialxcXuMu3Lu6x/2zHZv7V8TtCK5EE872Gy4ejXTdQuwSIl7EdeKoCJ1aEUrmgGuRS57HhQfbPdmKUPE89nSzFmnZmreTCBujpG2V+61hMGu+zWE5yOqKyDH7Km5by65sWwV1Ik5Xy2GVrq3nyif/jCq/fFo9qIF2+UQuWWSLp/dNyj07cbWsecm1rpQ0PZnmdd2TYYd+EGuKHE95eq1TJYzVg1VO9jvZYU3nmscijoOwlrMcBXnm0OkqJ3xSPHMamrSmQIBO5bDt9JC7ghcVQUQO1w5SpsmKClEgVhni0C2EkAkhM4REkCfvjorjVZS3ikkVrxJAKdJJsY+oc4IWQWFX23Ws+Qxy0FGxjcsTE21lVzo1zmLmJisq0IdM1Ix5aUNBDJUi1YtqDGp0upb/UbJYBJjl/iaXQz8BVJFfWV6qUDCfyAw7Uc6jsQmZTUhsupntZmLz4Ip0s8HeK/LBVKWKlgPuWiWbQspFYCjB6LYjm+2IBiP2C2nqazn3iECn5R503ULK4XA/17yc5msxxZCDgDGI00mRLIpAQNjEdbo0DmWxfsaY0Vv3N60yxFvHLFX46gcx4rE9KYKuU63VewG133AFcy7Od+ynDZuQGeJSZbhUIW6px5062Y/9q8hJ0PMqYHQn1X65tCsvbQYlEjEGOvpST12wJTIMUxV9joc0hirjjbX+uB8lk/lEOKtSxI5rmyp90LFsVkGkn6QRIFldZ0LQ8rney7VuZRNCOApUl0MfebyeytM1VJ8X3P0Xve40vBqaKO7zy20hZaif6/CKQwsuwzNc6lSYitAhoqj0QBFCApjNsK6X02EZqV5OCRpRGZjTe6hsMB/rkA5wZu6WZR5Fm2WoiDwpvbydracsvviAltsalmdpWd6E9vFZt9O3VeD6nc6b0J9/3DS8vvS2IRWNRqPRaDReOyLyO06+/6Zb2/6Dzz5FjUaj0Wg0Pi1vTYRDo9FoNBqNzzX/AvAf1e+/mzJbxcqPAr/nM0/RS+V1vw1rPJunTZ35ovftdL81ouHJqTYBRM5R3RB0IGgPQJCOTs8QlOQTySbMl8N0lb1eMOaHddrMDvMFs5Hse5I/BjLmNzVqIuK+1Gt/9L3iaVzmUfh4nAL02fmTZ3y/SwZ5WiZ3R1m8ee3is07PXdc71ptnl2mj8Dqmn3zWfXvV137Ra3ySeMgXOefHz1uLcGg0Go1Go/EmIE/5ftdyo9FoNBqNt4BXFuEgIhvgfwKGep0/4e4/LiK/CPhjwLvA/w78S+4+P/eE6mjImAmxX4AyrnUTnDEL4eSniIgjobgMFCeoE8QIamyrv+HynUdsvvQhem7EmNl2C2fBma2ccxMSiym9JvqQWSwz58AmZHoNxOpKEPE6jhs2oYwn70Nm081sholsynZcOAtGp5FOS3pEyvh1d2HYTGjIBDXOHlwB8OXdOV/44vtsv/QhAG6KqLGdO97dbwgx0W8moma2ceFeH+hz4KKbya7Maow50KlxfzNyb3NDssA7qeMLwxkfTIEocBbLGOGzCL2W8d5Rc3EuxMRZSJzHzDYmQg51/H48lL+KE0xIRUBAp2XceK9+cAB0LpzHxFk31/HiG2YLEBOdKcEUkrIJfhgLvrKOX15vb3AhGwxhTW9Zv47R74PTqbGN1LHrzmxl3H/UMn5eWcejF5fEYvVcNe3l+sImlLLptWzfhDKGchZBzOnUmXIZZz6o0BHpROm1rAtSzhe1jCl3L+l2ircgSrnG4bmfrOPQnU7Ltq6Wa6/C4pFOhKhC70qn5f4tdnQ9bANsQ8DxQ51UgT4LiyoODCqoKGLOWVAWK+kXKftvgzMobIKx7ZZSl7cjZsq2W7jsFt7pA4M6m26hCwkVZRsXzsJAkFLGGzU6NbqYiMGIUu6JiROrJ+CiWxhzYK51SwV6NdyLh+CdzZ5NSmRThpjIJmxCQCm+gk6Nd/uJoZ8P4+2TBfraPgfNzBrolDKSPyRG7enV2Ean03K/Bi3tuDglytuEUNuoSKk3wQSLAMpljDzoFh70E/c2e+6fX3N5/xHDdz3Ev/VOdUTIwUmgIaOaCepgRlAnxkTYTEjInOVA6BfCZsKycrkZuV4G+pAY6j3o+oWgRq+lL+u0+CPchWRa3BnidJowF4aQ2ITMRZcZqztinwPbuNQ2kxn6mThmNsE5j4kuLgfvBcB5LHlQ0erXgLOQD04BY/U5CMHBgrMNwlkIDLblLJYRy1GNTkvblJBBnXtf/JCcI+9cX/Lu5WNiv7CJibNgh/sx1npxFju2sdSLIKW+l/rttV+on1LSAnCRIxsvbwwH74hqhGBol9ie7znvJ4Za3jEYfb3/fch0IRFCOvTLOQWGuFQfiEGKTFYcIp06lqX+nan9kThWP1e/RJBSFl0orgqvrhLFqydD2NS8r54UrW+2luocUZTsMAQjZi3nlM/V265nDQv/XGW08Sbitz7v4mlv907Xn769hzW6IYRLRCL3+u8jSMdk1wB8QX8hi0zs/RH79JDsE5vwgCkvmCWS75m5ItsVIgPuE0efw8LRiVAtV0+sW6fMPKbPb72Fvb38/LzeVU5er/m8t5+fRbP+PDkRTqMbPg/5eVXcbnOvq6zetHv0tPScRnM92T98tA2/nCikVxnhMAE/4u4/CPwQ8KMi8quA/xD4/e7+A8CHwI+9wjQ0Go1Go9F4O/hBEXksIlfAL6/f1+V/+HUnrtFoNBqNxsfnlT1w8MJ1XezqPwd+BPgTdf1PAL/hVaWh0Wg0Go3G24G7B3e/5+6X7h7r93W5e93pazQajUaj8fF5pdJIEQnA/wb8/cB/Avxd4KH7Yf6drwPf+5RjfyvwWwF+wWW4a5dGo9FoNBqNxnc8dyk+bocBr78lj1NUrsJEkQBu9ah1GkutZ5bD9JVOrkMaQKQrx8jx3V0Z8rAcjg+6JYZzUt4Rw3k9f7nOL+aHSJL5Wftpdsu3cDeCDpgv3Ni3MZ8QiYAhEhEZTvJi4FbTf1oKqwDyLung8zQodwkK7zruRXQqd8kln3fsyxJJvmlh7S+L1z1c4E3nrnr2Oqc3fZOEqLeHTT1rqMVtXs4wqFcqjXT37O4/BHwf8CuBf+iu3Z5y7B9y9x929x/+wrY9cGg0Go1Go9FoNBqNRuNt4jOZFtPdH4rIXwJ+FfBARGKNcvg+4P99kXOIGNIlxIqMresWvrSZmG3DdSoCxKiZPi4Mm4luM5fPmNjGhU4zZ/3E2XbP5f0rzr/0Af33PobLju29ax5sb7hX5WqXMXPRT0Vkp87QLUWiWKVvqUoQO81s1KrU7ChdvOhntpuRYZgwU876iXtd4l4XuYyZqH4QtwFsL3YMlzdoTHQXeyRmvrR03P/y+3RfucZHwbMgnbENRugX0tgj6mw3I+9s9kUUmQP3NyPuwn7p2ORAUOPe5oYH965YlsicIve6+2xCJFbJIMB5LFLEy27hYhjp+xkV56KfWEzZdolBM8m1Ci9LdGtQZ86KoUjmIF4skswifuvUOO9mzvqJUGV02YStK4spYw4oHUHKs/WlCu6KwFHI7kVKl4Xk5Qn+RXTOoxV5nQMoi1KEcyEXQVyVE/YuxFXeVmWEnQYgYhQpZSdF5DaoMVl5DreYIAhnoUgwB3Xc17ce5ZihiiQ3QehE6UQ4i2X/XsuztFUCpwhS34T0uuZNCFLeSJiv7aWIIVfhIxR55pkpCkW+qNCp0CtVTgnm5ZhOqect1zEXVI7niiqYlfP0WgWPoUgAhwCDQtQixexDYjNMDJuRZe7oY+K8m/myC1GNi2Gk6xaCFUFpES4WmeMmZIaQ6UNpK6sIr5MiE43iPOgnHs4DQZzzGDiPkW1tW1238MX7D5nnnpt5oI+JOUW6YOQqBgxiPNjuiaGITgGGuHDeLWQTLvqJ5EVIeiY9XUwMcaEPuV5PD3X/PKbDOVeyK5MpyZRF9FCGFzHwzjDxYLvncrPn8vKay+99j/DFiXg11j7LUYcQquSx5kvRIiXsFyQacdgj6sSLPW6C58CDiyse7s8OfdZ2MzKclXyed0vNZyK7EsRqnTaiZrpgtS8s++5SZBucsyhskzDEBXehj4muS/QxFRGlOF2X2ITEGAKxSlcvXdiEyOMlYA73h5EpRaIFutpGxxwO78XGKGyD0OUexdl2RUTZ1/qhw4Itkf7ihsv5IZff/iLnZzelbmiu97/s36dYRJehY3MQWZa+YhvKfTt9Hr/PirkAkzO5oAAAIABJREFUwhID23nAsSJ01QnVjMZEHGa6kIkxMS6bUm5aJGt9KGUS1IoUNyZil9h2cymbHA99y0aNvShZSt+/CV5lxaUNAiT3w5N9rRLRQ/2yIpBd+7w+GJt63VIe5RxrnxSkCCTPY2k/krVNNfWCiMgD4A8Dv4zyouNfAf428MeBrwJ/D/jn3P3D15TExqfiRd665Y8sl6Ok/m2/fZ58XOPgLE/sUyIZvC5WAbTvD1NMCka2Pe7Gpvsi3xt/KYnELHsepZ/nZ+x/Yck7VDrMZhzD0oiTy/SWAJIOERXu+RiJUX9L+J35XkWRt78/jXX77fK5vX3N5/OkmreP+bhvRN+Ut8Kvk1YGH5/XXWZvsuf4aWm5LYB9dWl+Zb9VROS76h94RGQL/NPAzwA/CfyzdbffDPyZV5WGRqPRaDQaDeAPAP+Du/+DwA9Sfo/8LuAvVIn1X6jLjUaj0Wg0XiKvMsLhK8BPVI+DAv+Vu/+3IvK3gD8mIv8+8FPAH3mFaWg0Go1Go/EdjIjcA34N8C8D1Km4ZxH59cA/WXf7CeAvAb/zs09h4+PzIh6BU7REB9TvKgPmE0HPMRtR7WuUQWb1IyAKbofpLDfxAbv5m7jtERlQ3aDSoRoRFBGl1wv26QMuui/zS/yX86vfPeenHxnfzje8x3t8YD/HmB8yhHt8tftlaFS+yde4mr+B+ULfXRKkw9wOkQ5eIw/mdMW2e5fsC3O6YtWhZbumRCcERLfgS42+OC0tOYmGuMvTcHeZnbosjtxed7psFFfGXdfQW/uffq7cnqKv0Wh8HnhlDxzc/a8Dv+KO9V+j+BwajUaj0Wg0XjXfD7wH/FER+UGKzPq3A192928AuPs3RORLdx18KrFuNBqNRqPx8fhMHA6NRqPRaDQar4kI/CPAb3P3vywif4CPMXzC3f8Q8IcA5FTC0XiNfByvAEA+cTAt5BoBkPLDcrY8nbgXpEQVeFnOtgeMXb45+BQARBTzhWX5AIBN990AfPfwS/kh+QG2QfiD7/+PjOkhKsV75V68Dinv+X/kPdwNsxFnQeiYk2E21xyWaAuhQyRivmc3lX1xq7NrdIh0NW8ZsyvumiHiydJ5Xlmt5Wknn7ePz7euY7e+P80tcXo8J/u+iqiGt2VWhxbR0fgkvC31u/BWPXAQdcJ2Zri34/zshrOQDsK8xWFKkZQD7sIy9qTlmL3sSjYl58Dmckf/7hVcdjAmLBcR4ir5AlA1LEXCyY3cdEuVJAY6zXiV/pV/kAzmKpgr14qkFMiuOEdpX3Zhn1bpoqHBiJsZCRmvMjwRR7tUHESL4qagIDETNhO2RNwFFSeGXMVx5br1byQxWBFmxkTsFlTzQdp4Om1SkCLyC1LSliwQLZAsIGuaTUiu5CpeNKCrMsQgRTA4m1Q5YuEgZKQIDbMrbsJc71EQA4U5h2Oe/dlhkk9M7OKQ/Xitdduaxkz5abGmV+t9BZjX68EaQIl6+dO+lt+paNEp4kY7lJk/sT1omWBL5aQOCQcR5GESLinl7gfZ5ZP5CVry5DgqZR/zco8UEIFU8x3q8UGeTG8QwWsmojyZjpIXJ9ftXifoKud0khUxZ6x57GMqAtGu/DjoQpGwBilyvL4vP4zMBKPcf6u/x63md61z67JW4V7UIlNUiqyz01WUV+SsQY2uCltv5qHUIdMqRnS2y0J2RXHGaSAEK0LZkDnvSrrO+pnsyjY4gWPbWsv7tFxEvNYVQSkS0YChFBGhrXVGyn24rCLU7WZkc35D984VAOlmwzgNh7Sdnj+qIQJdyGgwbImEkJGQkS5h19tD2y79htDFRIgZr+2mpK2UT6yCwU6tyhlzXa8fub754fdzTUtGpAgm9aRcgpb7M1TpJ0CvRvaBMQudZpIqniNBDbOPqoCO1ykSzvW+d2qln7vZEIaFzb0d224mxMwy9UQt8s6zuNCHRJQBlY4hQKdWgnWrNDXK2i7W+lb7H6mSVCBW8VpEar0yRB2pdc9cWJbukFbFS90TQ7XIOKn7r+UWxAiipe9b+0AVopb7C0dhpIhDlbZS29S6Ptf1Ise+eC3Jw3/T+rG/yVV4G+ryaZ/QeC5fB77u7n+5Lv8JygOHb4nIV2p0w1eA/++1pbDRaDQajc8pTXDdaDQajUbjc4u7fxP4ORH5B+qqXwf8LeDPUuTV0CTWjUaj0Wi8Et6qCIdGo9FoNBqNT8BvA/4LEemBrwG/hSq0FpEfA34W+E2vMX2NT8Qa4nNbVKh1ax0e8YSc8LawUE/2KZF/RdbodRrKBBLLcArRwxCHbCMqPUEvAWNOj5jTI2702/y8/xTmM4ISdEu2PeYJlZ4uXuJupLxDJBLCGVG3mCeyTcRweRBGmi9l2kyfiHqflK8QGXCmmnM7Ts9Zy0HWMhHF/fZUl6vUcf1+LKcy1eZtieMt3EDicR9/+r6lHOXwfeVJgeXttB33Ws/yyXne9J2vMxT9NH93pePjhq69HWH1T/Iy78Fd5XVbbMpLvt7tYV13cZco9WWl40WGRr0MjlGYn4b2wKHRaDQajcbnGnf/P4AfvmPTr/us09JoNBqNxncS7YFDo9FoNBqNRuMtQXgygmEVFd6OaljfAa5vGet2Cahc4J5Q7aFOaVkiFmKJOtABs8Qm3mep0QlBe87iFziXd9j7Y4zMlB+z2J53ul9IL1su7D4mxjfs/+Zm+TabeB+VjuwTQ7jHnK+JumHK15gvZBsJsmHJV7gbIhGvgkvzGcfItqvpLwLJw5SXVRz55JvOjK9vX12qUHKdIvN0Wkw/7A+CF2HYHWV9x9tNz3evf8rRx2uVdPkTb4dfV6TB644IeN71X3f6PgteZh7vOtft6J6Xye3rPS0v+SnfPyteVhl/+vO8NQ8cRB2JGYKhXcIs8HAeDlK9KQtj7lhyZJ56NBgpRZYUSaZFtpdDkc5tR/TeBP0ZXC24S9nm0EmRpplp7RSLwKuPiS4kkiW208BioQoAiyhyykWMeJMDY4osS0dQqxJHqdLEY35WUWK3GMs40E8dogE3Zd5t2V2fc/bwks2jb5N3myIPu4E89aTrLdP1GRoy2ZQ5R8Yc2afI1TQA9c+S5iJq6xYsKykVyVsRjh2FkVrzHMRJLiw50OWjgDK7sk/KYkUauUuRfVai2NEzXOVm7gLiLC6YlXwGcTRFpqUjWeDhtCWZEtWKQDMHbrKyWJGozSYsJgxa5GtFPrnKFMvn4sLiwpy1CtUgG0wmxByKrFKcfJCzFaGbVvHaciL8XIrNkKXen6WuW+tWWRZGUeYsB3lbkU6ehgmeBMm5HMSMpwGM2YRcp/c+5snJVsWXq2SyXnvdZwhHOdx63uwlb50e5Ye6yiZ50hud3TE/CiTzrb7D8YOE0ynSv04cwQmx/nDz9cfaKr1T5rlH1RiXnjkHplpH8CLwW0zZ122lrBVbhZEu7Jb+kMZ0yLOiXqSsXq+xX3o0FWFrHzJDLO12MWWfOrp5YNvN5CowDGIELfdI8IOQcq6yVuUoAC35lkOb1CpCDRjGsSyzC9mOx0S1g1ywG2b0fMZvhP2H99hNm0Nacy5pyjmQrAooXbCseFI8h9K/9amYSwGzwJzDoV3lFJjGgetpU9JkSqrnK3ktaYlV8hjUmJd4aLPrfS3n1oOUMNdrrOUTQirnUeMsLid9GHTSs/MioxxTZDI9SFlV/JDWKKuA8SiwXfIx354Dy81A6Bc0ZDbDRAiZm90ZAENIVWjJoZ0JpZ8N4odzJoc5CyLH6y8mhzazuGP1fwlnykUqPF+dsew3jEvHMvXc7LdMqWNMkVjLcs71b0eKhJhqvX+y0Yg42YSptuki3C33erFVVFv6qVyPHbSkW9d65UXGm2q9yi61/ZU+Jp1IerNJlYZyuKeNRqPRaDQabzpvzQOHRqPRaDQajcZ3OseIhtPoho/6Ap70oouEw3qpkQxAdSQsyMn+Ke8AZbYdm/CAMT9ECOyW95i0RDWcxS8wpocEHbixD3lkP8+HMjDbjmwT7sZie0SmEiEhA/v0AUEHUt7jnsCNlK8oLoZc01jT4emW68DKlJiHMnhW+dSSeMLvcHv76fLpNJdPlNozrvOiyB3fn3Yt5/VFPbzptHJ5cd6uKSNfDW9W3tssFY1Go9FoNBqNRqPRaDReOu2BQ6PRaDQajUaj0Wg0Go2XzlsxpGIdO+sp4FPH/v377MeBTq34B6qHwL24BHKOLHNXxuvmwNXS04mxjdWtMCxID5hhO8XruFujjOMv4++VxQJRywjzoHb4t4mJvKzHAHU8bfAydnfOgSVFuq6Evll1Bay4w5hL0WcTUgrkuStjdueOcbfl0e6Ci+srzj+4LGPnTbAl4llJY898syF2CylF5hTYp8hY82rAoMYmJIa4sN2MxC4dx227lDH/JxFt5oK7l3HxKbKEzJIDiwUMDmPBy5jj9ZjTschlOVHGb88mdFLGXXe1fKcUGXPHLkWiONRzLqbMVsd34/V7KdvVq+B1DHqy8n0xmLMyGQwqB9fCOo56MUGDHRwQAQguh6DBkpcynjq7ENwP4/TNj9dzyrVW10Ne81/9EYbUcl2dGEfvx2G8v/ihrI2ji2EliCB6EgYqRyfD6Tjt9dzJ/IknhUHK6cNh7Hz5vrJ6JlROz+OH2688eb1sYFrqvIijalhWzIQYMkENqu9gdSasPoVcx9FHKXUqmZb6ZOFYLnX96QRBpQ7ooQyyFYdIMKnfhURZR8hsupk+ZMZczp1PvARQnCRDXIrDJBhd3Wa1DnOS56OTot7L6p/oattf/Q5BHJeyLSpsYmK7GdlsR/rLG6SH5Ztn3FxdFAeAKZ1mrOZlLatyL2qflgOYIDEjXfHTSPUwKF58CjGVupzCwV+g4qW/suJ/WMt2dRmIrE6O1WlRHSNy7E+DGqrlmOIjAQ3FBXEWF7bdgogzpUgfMiLFAzLnwOLH/m91LJR65wzB6DTQeUfUkgarzpXOBZs68tzRne8Jw8L52Q2x9pUlLRzS16nRiRGrV2Mx/cikUrn22UGdKHJwqQiCopgYXn0ny9Kx7AfmqS99WYpPOEagpDWblvuWAqgT1Oj7UucWC6UN1Pu59ldrHyHixz5R1n7ySHYhaulgcm07hqCU+xBO7wewnHyu925t41H9pQQ8NxpvD2tY+XEoxel0lkeOgkj3pUxz6QsiHWBku6oCxolcp3lU2VZZY5FHuifMEjv7Fl04Z0ofEHSLsGUTHrBPH3LeffkwHEMITPkKkertsR1m42H4xuPlQ0QiZjPmU51us6RfZKC0civ/TqabXMWY61SdhdMpJE/zfVuo+bShErdLNZxMi8kxDbIO77h7+st16su7p7m8zVHsefc2OE5v2kLiP0orixfn9D9yPsuhOs+6xmddpz9rOeuz+5kW4dBoNBqNRqPRaDQajUbjpfNWRDg0Go1Go9FovB087W3Sd5r07ZPm91lvJBWRgNARwhnuhnti6N4h5ZFkO3BDtcdsxskIAZGhvPuv02CC0YVLzNdZaJROt/R6wXfz/XyTrxGkzGr0aP467kYM5wzhHkE6xvyoTFnpE52ecZPeJ9uEEKowMtUpKSfcM9SIBmcpcsg1+sAdWG4JIp+MJvBbn3ctFdbogDK30jH27DTK4VZ462Gt35oWc41suD1V5mls4mlK1vUf3f4kz9r2Its/b5zW9U/C296ffNo+8fbxt8vxdNkRIk76FNc7JfDRqS6flha/Y9urvnd+6/vTyupZ9e9p225HTjw/Py3CodFoNBqNRqPRaDQajcZLp0U4NBqNRqPRaLw0nvam521/G/lx+aT5vfudfiGXiAGMbErUc5COJe+47L+HffoQEcXdIEC2GdVIynvOui/S6RkX+gWu7X3G/JhtfIdOtnzVfgmRwOQLX5O/waV+F/fsHR7q+3z38Eu5tvcZ5ALHmPyabXiHKANX6ZtgN2zCA27s2yTb4bavqfc6Vacdoxc8123rm1G7tfy08niRN6J3vW3NJ99vl++zjn1aep63/ln5aHyUZ9X17wQ+bb6fN+Xr7a0vK7oBnl/XX2Tq2s+SZ5XVJ03ri9fft+OBQzDCxR7pEz51DPd2fOkr3+Krjx+wS19k7IoILqqx7Wa2ZzeEmNkuI2f9zNk8YAh9SMSYCNsJBgUtAR6xXzgfxiLrAno1hliEaX1IbLoZVaeLC9mUbVwwF4IYD6o87143EMW53yXuDRMXZzdsz/aoGjlHzmMiSs82lj8u25gYQuJyM9JvJrRLaExYLmlKOZDmDlvKLbIlFrGkOpYDKUVCzEUoV0VjRaJZvm/jwlk/8+Diist3H9Gflz+AOUe+670vc7+PmMP9zuiDcx4z5zHxoJ/Y9DN9LGF0yYp4c87hIDYDiFLyFKpsLwqEpASBTpxOi/hsGzLbmOhDZtOVcjsLiU6NGKzIAKtosAhAnVBFa4M62Y8Syj4r2WHMwjY49/vEmJVBncmEZMJ5zFzGxGJKH/IhuC+KE9WKXE4MBToJiMCYlU0w3IuILTtMpvQGvQq9Og+6XKR1Na3ZhW3M9F7EdL0qZyFwFoWLmIlVfqfANmYGNRZTojq9KlEclUAQOZHfHcOWzOFe54y5lMsmlB8uucrp1j3v985Gi6RuNuFeZ8wWGLNwHp3zaPQqXCZlzEVudx6PyshtEPJJnFOvEBV6dQY1hn5m2Iz024nzi92hbgbZkF3ZbsaDWPJeP7FPRZYY1NiEzGU3cz6M7JaeTTDOqhCxD5lNyNwfRvapY0yRXo1eA0GMUEV9XiWPRbJY7HtdSGyGiYt+qjJHo4+Jvp9hLjLATTfThUwXyh+Xyy6xDT1RMyrONibOQsdlp7WcSh3tpIgKgxpn3VJkgXNfglJdDvLDb4+Bd8+vuHfvissvPGT40odwf4BvCFr7j06NISSGYaLfTGyGmW1cEIFtPxH7BVGvwsiSTq+i0S4uDLHkc3u+R8SZp55NtzDneOibgnT0MaM4Q7cQxJhzpAuZPmS2cWGbA+cmzPXftp+Jmjnb7jm/vC7lU/O/vdhxMUz0OXMxjMwpkk1LXrS066jGeVzIrof+YAqlj+iDEFLkPAbuseUsGkNMZFM2VTzpVegaz0fCxZ773/UBIWaG64lNN5OtCiA1c9bPGMJF5/RV4tlraRsXscgkobTbTp1RHBFFpQhMd7lntgvOpOMs7hmGibiZySnSx8RmOzJcL2xiIpmWvrNb2HQLMWREnRBLutc6l12JWSHAmAOdlj56o0Yf7BA2uAprN+EYZLxRQ0QPfdRS63dXRaXbmLiMxxDmtX8Vcfr6t8aBIWR6DYymBPlOC0FuNBqNRqPxNtGGVDQajUaj0Wg0Go1Go9F46bwdEQ6NRqPRaDQajc8pdwnMbofphjrNZR2W4BNLLlNehnDGw/Frhz1VYv0cmJZvE3TL9fR1Qjjjkf8s5jNBN4zLtxFR3rO/QQyXmJepKW/C+/x83tOFcxxjCPfYpfdwNy66LyOi7POHXMbvxjF26X1i2BDDhmwz5gvZxoPAEso0mSpbvMaLmk+H6SjX9JrNIIqfyBrLdJgLIkMZriF6KIPC6fciilzFmu7THfuvWLk+gEREujK95zokBZA6Pei6zrH/n713jZVs2Q+7fv96rLW6ez/mcR73Zd/ra2zHUYKCQ1CUgGQSIYVgESwBiogCkSzMR/OQkhC+hABSEFLCJ0COAgpW5AjJlhOEgmKwHUgikPwS9s01uTjOfZx7fM8589p7d/d6VNWfD1Wru2fPnpk998ycmTmnftKoe3WvVVWrXr1nVdWvMHlf+d13uSzy+fM9zdJOKfell7bZ3G9RysG9Fulk2S50n+bLmyFfxbNK+F7EFoXPkoZZ8Pm0LRSv4nCseBZ1Pm16/6sorH1eaXpcXh1uD7ubS/wc4pvjvErAeChPPfz24TQ+36Udj6Ztbtfzfe+31n349WquI381j5yb+6nHX1NnOFQqlUqlUqlUKpVKpVJ57tQZDpVKpVKpVCqVl8h1BGazMFIAC5ryNpNAChsOR+X242x5xkSIff48rJlnAaR0Dtg8+iiGMby/uyrEs/J6F4CebzCPSg/TN3fnnV3jzlJc7+9Ax0fvWi+NJV66/Z2Wbb72iYPCWRSpGlGefv5upFUDqv2TAt7xNGuMcnDPT/DUPTG+Zx74ftYLXsRo/7OE+WGEg9cVfF43vJfF80rT4/uL5xnLk+O8PIMiXvntR4M+MoPistrx6el5Wp16dIZVjvPxIb8+Dxw0G/jM0UCTHrD+4AbnQ5snJKkwKYRkEFGSCt4FrHs0w2K0xKHBhzX0IxpslraJ4iVPMJnlfVpkXap56sww5mlxfXBZVmcMUzKoCmOCEaEvgsUpeLrUE6IjRkMCgsI25EklYzIYsQyTJwwN0yZifWDatgzbBQ/6BafrFbe2HZClkWH0pGjo10u2mwXGRlKyjNExqeykdqak3ZDFe66ZMDYiNrFYbnhjsWVxtmAsgrpU6sc8KSYmwxQc/eTZTp4xWvro8CYRyfHM4kQr+8qVNEsJMSCqUAR7MQkBQz95xuRIyE7qGDTnRyxiwDnvs3BNd5N0Ysphx5TTa4qQ0ch+UlqCfB7gi3AwHaQvFkFbIpdHLHk2fweUCUHzZyVfykyoXNfYfTdGgxGKSBKm8mVOk4DmZj+Xy1xXKflsyKK7qLOMU3aTtBqTvxtTzuPOJqJm8aM5aM9WslSzEcVAES+aUjZZ4IkBb3K+Rc3vrcguH+PBPQXN8kkXDX2R1AGE0ROjpR86+qlhMzV5QpYKKVlCtCV9Nsetgi/iTIAhOPoSppUsFO1sxJvIRj1O9rK9PjpO7MAUPP3YcH+zZD01LA5ketOUp2IOyULIIss5b+f6m8siIaUOBFWG4InJMM4CvoO8nOOXgzqTBZY5DEuW9REc1uTzfDPhFj1mMcEG4vaIMO27VSX3ISk4UhJEwJqEMVqksLk/ktFhFiM6uXxuqavD2BCCxYgSJocpssg++nwvako9z3UraC6LXJ6myDbLhEuFKcEYHOKUphmxfsKYLJhUFaa+3eXhGBybscmizGRKPS35YhSNuRyNKFazKJRkSr0u5ZRkVy45fULsW+LkiEODWQ40RxvGiyUpmVx2yRJ1lkEWsWySXR93+edMimx2fm8g930ieBFMaVdS8miW7k7RMg4tU3RsJ88QHa0NhJjvfRgb2nYgBotGyzR5QrLEJAzJ7oSZkNvWrn2XPJn7m5xfade2fRH7JpOI0eZ8I/dZjY0sfEAVpmSxmvN0/n7us1qTijD1VfwjslKpVCqVSmXP6/PAoVKpVCqVSqVS4dGtJKXMfNDdEERZwy0+OwMO1i9be7rzD4gYkgbyMEd8+NrdWujywFv3a59zeHMaDtc0H3J55XJ6zLlXrQe//PlHyeOcGk9ad395Lf0jj4evCK9yNU9yOBxS83DP4/Lso86jw3r+KpTPVf3J5bZ4+fvnT3U4VCqVSqVSqVQqlUqlUnnu1AcOlUqlUqlUKpVKpVKpVJ47dUlFpVKpVCqVyieWFzH193Brtvghw7eIeKxZ8Xuaf5nftTzlH/Rf42vTr2DE8Sn3/fRcEBgA6OMDnOl4Q76T+3yLdbjDifsU2/SAqANGPKqRhb2JktjGe4xxjYihtSd8Tr6fM3OPrT7AYAk64GVB0IEpbVDS7nxvFkSdGMODfNdlG0hrWow4hukequGK5R92t2XlbrtITSAubwsJu+UfiHv4OqYizNSDbUIjMv9JX8Kav6dsWbmLYxfYvGzE5/RpOIgz23DmLSoPUY2PbPP38M3tt7Q8XMbySPyX01SuO9z69HpbYr4MnseykMdtrXjI5S0w58/m95/05SlZAJs5rFtXLWV6EXn0uKUJ8/G8/enlb+0L3xrzaub0XFWvnnTd03jaNpqvywMHBU0CvQMXme6d8ODOTd7bLhmjYROLtK/I6zQZNBpisCSVncwsqmEMnjR4dKvIFCC2O0ncLAecUpb87aJXISXZydhCymJIr2kvqitCviFl6WIqsrSU9uI9ATaxSCaL8GsbPCE4TN8ShoZxaBhGz3pq6IeWOHjE6F58NzRsNwvGqaELjnHKAstQxGLW7NMkolgbcYse2+6Fe40JeHMoC9xLIKdkCEVklpIhJMOkhkkFUySac84EzT9vsyxSZ9NyyrK2LHHM15NgjI4+OFSFeKlSp5LeKc2CuUN558NdxWGXYVBUH+5yTAlLi+TOFEnhobxuJ78TpUSJFc0Sx1hkjBTxZpG8WaM7kWhUwZtZbJf/OZGdsC4hO6ncYbPOkr39vbcmyyanJCWcfdjzsRVojDIKxCJFhVxfZwGdN7oTaXoDfZzfKymBEwjZY5mllkVomVSImtM/xnzcm3zcF1He0HfYKTIOLcPo2U4N28lji/QOIBX5p5W8C+/c7dgibQxqShvJctA5n6aU26iU/DVF7DfLDi+GjvXUMCXLgn0djqW+90UWOUa3y19FmJLFE7AmMUW3y7NZGrmTrCKElOO0klM9JZvlgclgjcFKymlFcJLwJuEFvJ/w3YBb9kin6LkwrRdZopnmfNmLA1Oa9x+fLaSShZE2IUazwNaHXVtPCEkNMTiSKOPYYE3K9TBkQeq+juU6HovEdiriSWfSrn5YKe0qGZyNdIueZjFgzhMrPxGiYehzf+hN3KWjcZGohoWN9FboXGCMNrc7yXF7E1EFY7K4tLNln+dStq0NdDYSZomiD1lkaxL+aMu0XuwElHMZNLbIfIu004tiTGJhc/1sS7+4k8fq3MZKuqTIUQ96jPme9mUiu8+cJETY1UdjFOcDxiYS0DQjzkS8SYwx19fGRlYuMSWhs4nW7H9w5UDyOAsfgSJLzb9JahLOJJzorqwaE4hqdsLVqfRdHnZ9dGcDm2hzn0ylUqlUKpXKq8vr8cChUqlUKpVKpfICeDFbBD6PETzBsWw/z03/HSz1mG/yVd7pE05aGrNCxHLBHe4Nv4U1LfNrVxLgAAAgAElEQVRwwhDP2cgdYho4aT7HOn6AMx1GloTUc+o+y/3wday0eLPEmyVDvKAP9/ly/DuPzgTQWSjJbgYCQP+QQHLOx1Qejx8K2g6PD949sl/dFdvZHXz2yGZ8Gg++C4+cdPj943by222f+VCcj553xaVXo4++fSTMqwKa06PX2ebxZfM82szjtlY85Kq8eB3y56NCebl59LSNJq9Ox4ud3ZBjuJqrt+388Dw9vOpwqFQqlUqlUqlUKpVKpfLcqTMcKpVKpVKpVCrPyNPcD0/a3vE63ojsL/hu+8/yI58+5l/6nt/gf/mN38mv3vP83elLjGlNSoHJblBNyMEYWtKJlXubG81n+QP+u/lKf86Rtrwn93jffp1BL1jYm6zDHcZ4RojnQNq5Dx5id3jVGuW8fluvvMfH3fvrzFXegeve36u2XWClUvmoeC0eOIgo4iNEQ7xYsL17AsCJH7kz+LIePa9pFlHEJFKyD60Fn9fwx+J30K3NOzUPnjj6nZ/By8PxQl7TG4MjJEtMhk3wjMliTV5fnDQ7JA69A2ZeX2xiCVdpTV5vTFmXbMhrrlM0jEODiJKSyevmo2WMjhgcxkasy+GE4BinhnFypGgYgmcTHZuQ07NIhqhCUJPXPfsprzF3iZ2soKRnnkQ3p3sq6793a8zLvU/JMJb8McCYTHYqlPzMa+HZfaZoeX8QrghNigzRElRoTWJKhiFZhrIefCrei3mtf9LiSChOgVwmea32fE7QvHaaBIHZpyFw4JuIyezKaf5zIc7rtKG4D/L7VNalH/4WzudAdhSgsvM6pPKZkX0aE/vvtZxrRHEUl0IJ3BklKniEiexbkBKek3zcGsGZvH5dRFk4mCbJ7gaTw+hs9nZ4k1i6yJiEPjqcURY2YsWwdNltoMVP0VoAobP5Vp3AZARvsgNivt/t1DAOLSKJGPd/zPXR4cqU07YZdw4EaxJjcLkus18rP7fDRPFtlONt8PhSFyj5P7+P0bAZG9bBAzAmhyoskiEkSyqOgCEZxlDkZAfej9lnEJPZeSPmPmHvcYBJYUh5zbwqhGTwZt8G5nYeY25TjY00NtE2E64bME1AE6TBEQdPjCa3axUaG3OcJmLK+v6YJIdVyk1jlu2kbYNGS5oc49hkJ4IkYrm3KTjGkD0okD0Hc7tsXcAExxQd66nZuR0Ssm+fpW7PXoUZudRHmuJKMKKM0TElzc4GsrclFk9NdkHs3QRzu2lsLGW8z0NT2gNkt0GKhhQtadsSNh3TtmUcG8boCMkwRIc3kTHmcp7b7MKF7KIo6d2ponT/X4Hsq5idKEIkEuc2Z3M/mqIhHfR3e7cDB78ZpXySYGyi7QYaF0iDENUQIzt3zlz3XHE1hGR2bZldGmWfB5fynDnvS74rijdT6ZdyHuTfN6ExEWcTXpQk+lBZViqVSqVSqbxqvBYPHCqVSqVSqVQqrwLXVZU+7mGYYMwRRhwh3n/MeULrP82f/tQf441u4m+9I/yFd9bc639yt6uD6oQ1K8YwkVJPMi0iBtWEaqKP9/nG+C4/NfwaIa4BSLoFTLHEx90uDA97Ax43k2G+9+usvf+48qR7f9rMhaetd69UKh9XqsOhUqlUKpVKpVKpVCqVynOnPnCoVCqVSqVSqVQqlUql8typSyoqlUqlUqlUKtfkOlPinySMVFI6JyGIePLYV17GoBoRsaCJcXqP/+zrP44UeaRgMaYh6haDw5gV1rQANO4YACf5WNwNAN5o/inuTV9n5d/kYvwW3uTzQtzi7IIxPMBIQ0znWLMipRFlQqRFdUDw++O0LbdWxuoOts483BLz2fLpRfHoVpxPPxf245DpimNz6fVpYR2Gefn8J4UxU5deVD4MT+qDXgavWno+Wl6PBw5OsbcnCGDCwLG8i/WBz92/uZPjnU1FalgEWg9L2gwJydJAFeLQoLNkLljC6JlizgpnFG90F84c5ixGG6NjG1yRBSacSYRksALG5C7UmoS1YSd6hNytWpMFdIcyMWciKRlidBiTBXOpCOcAjI34xUAqwjpjIyntxY4xGaZZgBeF0ebjlZvo/ERbpHZh3QFZUhbV0NnEpJbZ6+aL1O1QQDYlS9QsjByLHM2KMiRBi6Rtzpf5NQEWGFOWtk0q2GiJJtFEy5AMIRmcKOvgGaOlLyJJUpbcjdEQFNyB9DO/zgLCkj7NQjwngFGIPCyFVAGTiMns7iuqFDnkXlCZNIeZyufwcFcwJGEq95MO4h1LuFrCyPkLYxQam+OyokwqmCLP7GMWXUIW1G2DYA1MCSCnp7NKOAjTiDKmHKcXZUrgbf4+JCEaYUzCyirOJJpSh2dZpTeJzibGaOhLHjqZw2Yn4csiyT3z9SlJKdVcf0Iy9NHiSx5aG3Eu7MSMQ8ryyaEI/6boMMwCTyGK7MSQqiBG6aNjHSx93Le1fmo4nxouJr8rFyvK0k/I5BmD3QlCo5qSlkQ/GaZkcSmLQkO0TMkQNcsPkwrbaDmfDH3M5fRB73GljgQVltFyouNOzHg2NjsBKsyC2oQYRZNB15Z4tiSMnnHyhCJTzfdowCjGKDEJY3KEaEnBASMpWgwQNx0YJYye9dAxJUtIln7If0CH4BhLPxVLOtbBM5X+DWCMlouxwUpChL0gMwnh4G+7EC3T5Amjz2Uas8BVtQgvk2FIhrOx3clZ74+Oi2D41uaIoMIQLW2RYiayQDGVtnE2CZMmgkKIhhAb1sHlNnB2RL9e0N08I24b+vvHbC5WjFODqjAly8Xk6VzI12puN+vgaGxkG2EbBSv7ny8DD/Vd6yBsA/QpHdxzriNpsvR9xzZ4hrFlirmfSwgh5jim4BjGhu1mQdOOGBeYJs8ULevJczZ5BOiT4Ww0RRTrmJIwae4vcjvTXA5YJhU6k5jUcRzz8Rj3/ao1yomfdun1JtIHx5hynZ2KjLIxiTFZ1sEVweR119NXKpVKpVKpfPS8Hg8cKpVKpVKpVCovkWfZzvDJ22VmaaOiOiFYRFq8OyXENcY0fLb7AX7kje/iU93Az3yj5e/Hv8eD/h8RYl9Ct4gYYhpQDYzhgxL2wyP0D/T/RcSyKaLJwyevId5FsEQZAIjxvMxUSKhO5P2r8kPAfDzf2qFg8lUdqXyWdB2eO9+bHBzP79PBq3J9eeh8/lWf1S0yKy+KV61evWrp+WipDodKpVKpVCqVSqVSqVQqz506w6FSqVQqlUql8hQOt4a86vPD70w5krz95ME584yGRfMmp+6zfHf6Pn74M47fffsD/sV/728y/OYNwubX+blfuMmP/X/v8e72V3ZhWrNAxHCj+yJfSN/P2qy5wzsEHVhP72PEsXA3MeJYT++jpN02mQBJJyCRNIBOiHikpFUlL07Tcs6jzoJ5KeCUvRIcuhsOmWcCPC6/npRvz8rTRk2/3RkE+pj3zxL3dcK/ekvUR2dQfLJHhyuV150XNsNBRL5DRH5eRL4sIl8SkR8rn98SkZ8Vka+U15svKg2VSqVSqVQqlUqlUqlUXg4vcoZDAP4jVf1lETkGfklEfhb4U8D/rqp/UUT+LPBngT/zxJAEOF3COCHG4MKG9HWDNYm3luscWWqz9CvZLHHT8nRdlCFZQjIsnEWHlv58RXu2xK56xEVcM2FNYmEj58FkAVq0xJQFaiHl92NwjCHLvnwRlOmBSG6W/M2COzEJaxJNM7K0gZVLeFFCkaxZstRtmnwR3kkRy2XhXIg2iyJ94LCo+qnZ3dsstJySZPGh7p8IG0lYF9Bk8DcuIBlcO3Lc9nRW6eNejplKWqwozkasJBobsJLwJqFAYxIiSlvSZ8v583tDXu0XVXAoSXP+WJPKeQYDtDYionhJqBE6G+ljljIKijNZVGjkULApeIFBKZ/l9BhkF49Ifk0qNCYVsadibaQ1KYsDD/JNitDNlTghP4HL91OEiiYLFmchnSGv6owqDEUk2RfJ5Vz+uTyyELGxWTCYJJd5Ikv1omax5pAEq/nZ/SZA0H38YFgHoUsGIxATjAhjAlNsn2MSNrFIPL1gjbKOpuSn4f2hwYvSR8OQhD7u0xkSRM3/cl3O0sspgS/CzylaYrR4H0gJQrK7+rKr/8ERgnuo7h1iS97v66XuBIzH7cAQ3E7gqQpjMlmWFxxnY8P55GhsKmk2bIMnJmEzNQylLo7RMowNSQ3DlGWkvkhYp2Rzm1alD45YJIRjEjYBOgvnwcC2wRnFCIwx9wOdjVxMngeTw0qWcU5JeDAZQihtMglp8EwXC6a+3eWFFsnf3FatDVijmJRFf9PkaJJgXNjnjQ9YH2jdhJXEGByxiCKH4LEmEYPfnZ9KvR+jpTFhJ2H1JrdJZxKxpCW3jyyDVRVisMRgGYuUUlUYRs8QPFM0uW8qQtpQXqck3B0bpiT00XDs8/2NpX4ZgSkJ6wADE1HbLGQsMsk+GjZnR6gKGku5DE2R5Qp9yFLevsgZfZHyGqHUX8smzKOK+/rWmH2biArnE/RR6VMkSKTXwFD68ZQsIVr64AjBkpJhO7mdQDcVCWko52kSUnBsN4ss8Sx5LKVdbWK+sLPCvdExlb5g7pObUqemBK3JfYUqDEUi6yT3U43NUtFZbDu3kVjybir9hRFY2kQfZSdDrlQqlUqlUnlVeWEPHFT1XeDd8v5cRL4MfBb4Y8APltP+GvALPO2BQ6VSqVQqlUrlFeBJ09vn72b5YN7OEnGgAedu8qdu/pssLPz+Nx7w9uqCn32n4yfevcdvvvNrbP7dI5xtiWlDTD9TljfsJY1RszTyg/Uv8wG/ylUCw+349Wuks5xRwntWnm2C/3XOflFLBl7HpQhPWm5RqVReRz4SaaSIfAH4Z4D/G3i7PIyYH0q89ZhrflREflFEfvGDi9rpVCqVSqVSqVQqlUql8jrxwqWRInIE/BTw76vqmcj1pn+q6o8DPw7we79g6hOHSqVSqVQq3zYiYoFfBN5R1R8Ske8C/gZwC/hl4E+q6vgy0/jxQACDiIV5O0oNKMoU7vJX3v/vEPH8N+8v+EL3B7idLogSuO2+yHa6S2NXbNMAZSHiLjwEkRbVIYeJybMnCvMWlplZWmnL+e4R2eNeaHlZDvk4rhIZvspiw+sKIw/v4WpR5p6rPjv8fM6/q65/XLhXCToPedXytfJ6cNX/Nz/qunQdYexHFffLbUcvdIaDiHjyw4a/rqo/XT7+loh8unz/aeC9F5mGSqVSqVQqFeDHgC8fHP+XwF9W1e8B7gE/8lJSValUKpXKx5gXNsNB8lSGvwp8WVX/0sFXfwv4d4C/WF7/5rUCHCfYTmgP/Tfe4PzuDfqxYYxZ4jgVMZq3ATEJ4wKmiOaiCqGI5RqbRXLiEmYxwmKk3Z5zsrrgRjNwf9pnSWMD3sZyP1okcHYX5likZyL7jZFEFG8SzkaaZkRsom0mOhcQIBTBl6qAgDWKc5EQ9k/pIYvzohqMD7hlT+xb7OiJwTFMHmcjxiYaF3ZPjewsNpxliDaCUeKmQ8p9aDyQ2BnFyl4iOF87E9UwRsuYDEGF5opimQWAsYgwY3ngHzVLH2eho/KwaDAmg7eJVCSPKY9DoEWodpmkspOt5eMiiCTLBuewD1/nePf3U0R+Jb06p1vB6iyThDHl8KNmUaO1c3ntQ1PNokZnclxDhElz+g/TkMpxVMnyyDncIoFTcnxR2YkmeyjSyCyIVISmFPKUcpoG8rNKJ3vJ5DqAFcsmmJ0Mso/CJMIY83HSLIsMWsR7SR7KN38gy7Syl4o6P6FJcCYy56pIrrtGsuh0lo7mcad8/cJNGMmhuwMpX5bkRRZ+ZIwWKynnT0lH5wJS6hbwUB33JqIIQQ0hZQnfLELcl7VhLLJFb2K5zjIlu7sng2Ik550vk6h29ZYsYlSVnZhSFULKfU1UcCWNmoS47pjWC0JwpQ+INLb8awesz/3RTlZa8tD4gHFp994ebfEXW9pmwpt8fkpZIBtKPuXyyrLOMRkWc9nZxBB1Jzid45/lrkZyHY1p348Bu75nSoZp8jkOuxfQGvbvY2l3ocgLtbTLSbOE0wCbKExpn5+C0pS23ifD0LdYG9EkgCXFLHI0pQyS7uuBlYSVPCY597mKMiXoY06byH4cb67fm6D0KTFo3D3k19Lm57qrKhiTMObh0bSohliktd4FrAvEIgiNKfeJQxI6q3jZCyEhp+mQKWV5ZGe1SDMVZyh1ikeY+61Zvjv3q9NB2xij0JlcB+Blj1m8PojI54B/BfgvgP+w/I3yh4B/q5zy14A/D/y3LyWBrw1zP/s0j0NEFYxZsvBv8UX7A/zY51f8/s//Y5IK/88738lP/pMVf3v9E/ymDmWmQb72PN7h0dH5iAKq4aHon1b/d9+X667e7DFeer1WiI85fpW4btoezuerX7ninCd9/rjrn/XzSuXb5VVomy8zDa/C/e95kUsq/iDwJ4FfE5FfLZ/9OfKDhv9JRH4E+Brwb7zANFQqlUqlUqn818CfBo7L8W3gvu7+B8s3yGLrRxCRHwV+9IWnsFKpVCqVjyEvcpeKv8fjF6/84RcVb6VSqVQqlcqMiPwQ8J6q/pKI/OD88RWnXjkkdOiUEpFXa9ioUqlUKpVXnBcujaxUKpVKpVJ5ifxB4F8VkT8KdMAJecbDDRFxZZbD54BvvsQ0viJcXzQo4kHTwXIIg4in9W/Q2hP+SPOD/NM3I//a9/9DvvP3/AL/18/98/ylX/zd/A93/iro32dejGqkQ8QgGGK64Mnixvk50WXpYIkfQR9K/1UCwuveYyUz59fh65O4fM5VIsgnCTrn7z7pZXQdyf4nPY8u8zIljZd5FaSVhxz2e5fb8otP10eyLWalUqlUKpXKy0BV/2NV/ZyqfgH448DPqeqfAH4e+NfLadd3SlUqlUqlUrk2r88MhxAhgQ4GcYmT2/c4vXeDD7Yr+phFeX20WJuwJuGaCe/zFkleEsZkwaERxbiAXQyY4/x01Y/nnJye8ebdNWdTsxPVNUUK50x+ej8aRyKLy4wojRoM4ORh+aI1CecCrhuzKK5I67JcTHaCOpEspovR4P2UZXKiWJN1YFZSDqOdEBdJk8WYlKV0NtK0I4u2Z+EC3uyVjsJerqjREvomSyONYnzcyf0On2vtBGUqOBuzlJK9xG0nWEyGIWXh4VgElLNQL4sReegx1ixMTCp4k5iKXBBgUsOkwiYaxihFVDcLFcFKzqtZ0DgzpSyGm4p40dssKszixSIQTWafdrJscCryvzld007iKCQUo0JgL7uLJY7m4MmfNYojS+caoziT6KzByV5gZ8h1zZsiJjzIizmvKWmyktOQNIsii0t0V46+XGyLQNEbaG3+18csrXRF9DiX5SyTnGWISQURdtfOzclK/twINOX6xsDKKSuXWLlA50fadqDtBlI0tM1IdyAqFUl0XQ/AWb8sbWwWRgZaN9E2Iys/0dpEZxOdjXiT8CYxRoeV/L6xSmMMVpTWBRZ+pLORsZRlTAZM2gkXVffy0FnG6Eyka4RubHEm0jYTQ/AY4MgaWhtKmSmNzXniTJZlLlxCdZ9vkwokgxelM2lX3+Z8njFNIG5bALyfcC7QusAJPbePzlgcr2lP1kzbjs6PTNFkqWw30BxvsMucf+7GBrkpdOYDbnztPnfPj2ndRErmQFab88KgTJidKNabiLcBK770R4pBd3nrjUGgjP4JtogS26MN/v4JQXO7dC7kPkbncBMpmd3GdKnIVUFoDmSLXhRsboM2Cd4IHreTKc5l2cx9nVFQwczvAWvDTra5VKEt761ROqssS91Z2Pxk3gCNzeU11/8psavrfQJXWpPFIBJo/IRrR5aLLQuffyNMnwW6UzJ4k7CSstC07Vkst3Q3Lpg2HUfJsDw/obERHyxeFGuVlVM2QfCiJLMX1Tp010/lNOY+tzWKN4rVXM8e+kyUxiSiCq78DozJ5PqYhNZoEZtSypfKh+PPAH9DRP5z4FfIoutPMNcZ+VfAlu0lTZndkPsEZ0+wJmtsx3jBL4Wv8r+9903+wjvfYvxfz1H9mYMwZLelpeqA6qyWvq4G8mqZ4fXG6eqo8LOhj3m9zjXwbOLJp333SeLyaHTl2fmo8+2wrF6F2VSXZzDIFd9dfv84rgrjqu+v5vV54FCpVCqVSqXyIVDVXwB+obz/x8A/9zLTU6lUKpXKx536wKFSqVQqlUrlQ3M48vNhR7WuG9ZVa3CfNqqWZyccbFb91PDzxtXzhh5lJoGG8n2eqRDiGTGtsWZF625xn99mShuMuEtxzTPFFGuOdjEpiZQ2Bx6GwxkPOc3ZG1HSIZdWBeuBE0DM7ljREmaEh+YcPnQxD+flk9ZfP2k08Nst98fFfTnO6/k1Hr3Pq+7v8LOyZfpB3HO+HR4DiNict2JQjVefU8rwqvAOzzm85vC6h9N+3ft+nbhOG33S8czHLV++XR6XP5c/f1H59aTZApd9JvDiZ/E8zaHyrFyn73vyLInqcKhUKpVKpVKpVCqVSqXy3Hl9Zjg4C12Deauj+x5ovvJV3jo7IiaDlVucTY7ORqwNGJtI0RKCw5rEwgdUwZmEM5FmMSCLCVoDSZEu4NqRhR9ZuUAfLW1xKjQ2exzmdeLAzoHQmISTREJYubx+2Jd1/cYkbDPRHG/w905obGDlIttgcGWtrpG8vt7a/ORJRBGj+dryT4yi0aAhjyD4Ztqnw0TaZqQ1cff8KvsIyjpmP9Est7huxJ2s0WB3nojWJJY2Ycv6aV/ux5uIqiCiJPIa/0mFmITGCGMyjAcuBFV56KmVNTy0XhmyR2FOswJDMnQ2EpMhJENIJZ6UXQ3TQx4HSCiJ7G2AvE48qOTXJLu141PKaQnJEMgegbnsXFkXPR2kd/ZWjGXNuSnnXo4jHTwQjSlfM+e3KXlnDXiT12q7si7b7upLLlsn2WWRNDsW5njiQfhJ8/mxvKLFVyFC0OxYcCWPD58lRs1piWnvGZgJafZzlHEPKY4Hsz/2JczOKkuXOPaRYz9xvFqzOj0vbcrQFC9KdlyY7BxxkaYZd3XYFT+Dl4S3cbdevrMpu09sdpo4E7kYW7yJBM0+gtlZMbe7ndekOCxSMnibPSYyzmv3lc4GFsUlYW1iMXR4GzhaXSCSsB+8xcIJjc1eAGdSacP7MmuNMu9415m0G/uJKlijxCg7D0tI0HQDthsQmzA+5H82sVxsGceGNjpu3HjA8vYDmrfuETYdjQ14mx0v3ckad7TFrPrcvhuFpgE34ZuJtuS1MQmn2b0SkyEmIc2jjrL3wcweixmZ+xhK22Lv8HAm4nxg8dY9js5WtDaPGHoXWDYDIVlCnNdX57hcKR8r2akgosTS5qxNSJKdb8AbYSGOzipdCXPlJjbR0i17ptFjlwP+9ALz7htYG+jaxLIZ2QbPGC1LP2KNMkZ2/UdnY3ZsiGT3RnGYuNJfze4SVWE0QlRHmxo6sXQ2cHx6zuLmGWFoaF3Au0DjAp0NxOR33otdvbMRv8p9aIqG1k0c+4mQTHGwKDe8pTGGlUvYJKV8cjqCCE7nugVt8V50VgnFP5KAxqaSr8VvQnH4iKLB4QFnZNc3dzYCNv/W1BGuSqVSqVQqrzCvzwOHSqVSqVQqlVeW5/nw57phXXXedcSLV03pfXxY++UUh+yGFcpRfkiZNDCE+/TTB6gGlIjqdEU8iZjOHonv6tTnNKvO6ZaDJR1XpP2xh0+ayqyPef+k854XT4v7WeK8TvleFkDGcvTwsosrUzIvXdG4O/NxMV3+bj/09Jiwr0zrx5HrtNGXLRx8nXjZ+XRdwedHJUQ9TMN1ls59O+E+G3VJRaVSqVQqlUqlUqlUKpXnTp3hUKlUKpVKpVJ5Bi4LwgzWHudvxOHtCm+WhDSwGb5azrkstnz4+uuLzeTS6+X3dXQ4M8sjnzaqepXs7Vn23H1WKd1VYR+GcV2h6SeBZ5GFfpK53N4f1/6fZ79gebW3cJ3v9dWoO3WGQ6VSqVQqlUqlUqlUKpXnzusxw0FB70zIcgLnYDsxfusm64sVjQ+s/EhnUpajTR4A1+T1glYSVhJBzU4KGEaP+ATOw/lEvL9ie7FiOzX00e6EeFDkaiZLxJyNO0GXFcVJfgJrULzRnUgxJEPTjtgikpvJEsP9bY0xi8z6oaHxEyHk4hiDzzKxWWA4NISLBXH0TKMnxCx/DJNnnDxTMkTNMkZb7nFMhmnyhNHDgxVxyPmyfnDMemjpo2VSgZSFZY2NdEWoZ4vYLBZBZB/NTkSYgDFm+eJ8fSKLJaeDB9zz+UayRM6oMCXDkAxjNKgKaiN9tAzJ0Md9xgxRGBNAlvSpGsYkDGnO3yxJHKNhSDAkISShj3lN4CaaXX7vn6g5NtEU4WMuh20w9OU6MPhSPjks6MuDy/7gflMRWm6i4IzBlPiGWESTKV+vB+VsRSEZgsJYhINqcribAFoePubv9+JEK7JLwzbmp4OThTHm1z6CiVkiqZAFiCbLS8eU12LmPMr5OSXo415kOcUs3wsKS5d3ERP2YyIrP9I0I74d8cueODn8g2NckS4m9kJBVcMYLH20jDHnyzp4hsljXSyiu/RQ/Ryi29Uz1ZwP872P0e2kolMSjNmLKtdTw8JNOxEmZEHiXG+HwTJFAzimyROL/NDOos6U5Xtz2nN+5frVmr3sMws1lb60AS0C0W0UthHGvkWjJWw6dHK4bsSPPW5o8H4iJoMxCSQhTcT4h0WYxkbEB0hC2rTo4LHjlnh/Rb/pSCqM0aHkvqCxRXDoAmO0B/cBIRrGkp9JhcZEohqmZAnJ7CSGjckrZ7OsNsff3bhg6SdEsvzRmkRSg7O53Ga5KmQpbkgGZ9IuXG9yO9NSHlPKfUFCswQ2WYbg8SZlqWuwhMkRNy3Nm/dz2bhIY8ddGRpRrMllOo4NUvqeLMbNwtO5L7B239Zaq4SS1rlumLJWWFUwJmZR5Qc3aN2EMYovgtKoBlEIyTJGZRwbpslj2gm7uBEVCX0AACAASURBVGB4sKJtRlZ+ZBscochwswAy/wYkoNd5JTu7PJvvSSTXcyu6F9+q4EWwNp+XSp+RSrnP9RFyP+uKMHYW4lYqHx37LRRFLCItRhytu8Wn3e/gxz7zaf6FL/wmv33/Fr/6wRv8p+/8bYbpTtmi8vJWh+Zgq8rDz6/DdUbsvp1RveuMfl7eTvJ5xPu0sA8/u274l2d/XPe6q2YrHI5NJi6PVcpjfAw8pNeer70qnifNkPikjvA/aWvFT1peXIer2s1VefY88+7y7IbDmVd6xevL4Kp+6irfxIdJ4/WurTMcKpVKpVKpVCqVSqVSqTx3Xo8ZDpVKpVKpVCqVl4aIB00gbvc+pnMmafnhNz7PV86F/+T//Cbr8ZdJuj3YmeKq0a/4Co7TPsvMiRe5U8WH3aXi8PzrrDE/DPuq8y9/9vDx41MWL70+Lownh//J5NVrHa8+LzvPrt6T5eWl6zo7oVz33A8TT6bOcKhUKpVKpVKpVCqVSqXy3KkPHCqVSqVSqVQqlUqlUqk8d16PJRUJ0kWLMQN864L4wZLxwREA59sF2+CZVDDAouvpTs/pbp0xDQ289yZWEqPuNV5a5IOEiI6AKM4FYjL00eJNwtnIGByND3g3YW3E2sgweU6LXLKxkSkZrFFuN5Fvbh0xCUs/0q62NDfPMcuBbrXF2VkwmeVlziRUoXWB1XKDsYkUs2xyCo7TZuTm0TnueJ3TPDnERtrllpPFhrYdchwXKzoXOPGRPmoRlCnHfmS52CJGmYaGFC0pGvptx3pqOA85P1qjrFzg2E+s/Mhx23N6dI61ie3Ycq9fFNmf0NmEKQKzPmbJYmOzPM4XeVoskrPOKob8euyylK0tosHOGKxJLIuUDrJccsZJlkG2Blqb8j0FAy6L4BTh2Gu+55TTNYqhTcrCKisXaYt8btalLF1AJs8YzU7ipgpRLVilMVrkdwoYGoRW52uVZSm/LHY0eCP4ck1nE53N4svGwspFEns5pTeahZRa8pAs98Sxk/FNKW+wE1KWRUK+16TQ2iJ7lCzjm1SRUoetydfMUsBZ2DfGLAjsVRjK7MRZzCiSZZGTZsmdors45/tpTKJ1gaYdMTZhfMR2I8ujDTf7Mz49tFij3Lp1j8XJBed3b2BEiaU9GFG8SXgX6BY9R23PsQtsZ4GjSTiTuLVc82C7AHwpA3Am7QSJq1J3AHwRGJ40Pc5GurFh6SICLPxEt+ixLktaj6eG1k2c3nyAOw+cNCPQAewEqSuX2ztAY3IZz/W0KfUnAa1m+WYScCgx5XJZHa/xpxfYVU/atmg0aMpSWnexyuU6esRkSaTtBtpmpA2erh2x3Yg5HiGBDKG0c4PpRharLfZOYgwOa3K7C8niTGTVDEz9EpFyLy5gRbmxWNO6JgsXJWFLPT/yTZE8CmeTo3Mhl083YFYjzckFrZu4GBtEUhZH2hHvJt4aOpZjw9nY8kByP3vi8zTpSbSIELO80IriUxazLqzgxeAMHHfb3NeUstFkMDbhjzeYN6A7WWcpbzOxeH/gRudobOTN4wcYk+/lxmaFE2XlJtrSlS+s7iSf1igxSRZNigGEoIZpUlo8jTG5jty4wL21Znn3jFXbs1yt6YeGlR+xkvA24W1g4UdWyw1HN85wty4wJ8pR+Bar926zPB9ZTA1TMqz8hBWlGRtWLtBHy9bYnVw2mtwuZx2aF8VapbMRK4YNhqZIh1uT6ErdzO1fWPmJRZF2RhW2RSxsRdFyjjzOXVepPDcsIh5rVhjxLPwtbpvP8/vcd/HHv3iX3/GZr/OTv6b8lbv/B0Y8p90X2IQ7DNMHoIFSWy+FeVkaCS9/SnTlenwUWw5WMjVPn50q2HwVqTMcKpVKpVKpVCqVSqVSqTx3Xo8ZDpVKpVKpVCqVjxA5eGf5y1/8Yf7w9/wGAHfPDD//jcR/8JV7vPvrv0VM/5AYz8tshnhw/bzlYd4ezpoTkg4HMx9m6kjkq8flbfOe9D1XnHd5S8DL237WMn88NY++fQ7rWJ0h8qpQZzhUKpVKpVKpVCqVSqVSee7UGQ6VSqVSqVQqFcAiCNYeI+L4weaH+Z///P+Ivd3z3/9XkX/757/Ab8mXCHqXY7vmd6bvxTWOf9L/AxRFEJCGh8azNBRXgxLTGY+OcgvZYgT72RDPg8ujmx9mbfeTRkpf5VHU66btcTKYy5/PM1bkMd9fde3hTJf5s/l4fn0ar2r+vmgel7+f1Px4Ei9baPSk+F9WeV2VpifNWnpxbpbX5oGD+JB/w7zgvi9x8tmvYduR6Tccm7GlNUpnA8cn5xx97zuYz3WcuHe5ffcUEWUztliTWPiR5e0HyE2fAzYJe7xlcXKBNYljP7FwgRtH55yvVxwfnbM8WqOahYsAY3QMwbFsRlSFZTNwp+84mywrFznuthx95n38d2bh4+qtu9z66jmn5ycYoLORt1fnbKaGo7bn5I17iCgpWppVFqy98eAmR6s1pgmkMQsjCSZL7dqBo6M1ftnTdgNHzcjNMLANjpXLQrfTtmd1tGZ5+wHueI093RIfLBi2HQs30ZgsY3yr67nZbmlc5LjdslxsOblxhmtHQrAMk2eIlqDCsZ8wKKvg6aOls7HI6AxDMmyDY0pZpnjiJxKwtIHTtgegcZHzoQWy9GzhJ8Zos5hy8lmkCGyKyC9LKSNWlCFa+phlbJtouNEEbrcD6+DobGSMlqX1dDZyqx1obdjJ1AyKM5HWdkSVIoaEdfBsomWMhpWLWJNoTWIdHH20rJwhKbu4IIvgxmi5MzSc+MDSBRbJcH+0gHCzUd7qxny/Nu4EoQZlUoOXhk00tEaLXM9iRNmEnKqVE6xAVOissglCa5QLEZQsoLMiLN38XpmSEBQ6ozQWxiREzULQhJC0CCUFRHL4Swd9zO+TZgmnFbjVRG63Ays3cdxu8d2AbUdsN2Daie54zcnkeGtoEVFOPvUB3afuYmzi5L23uNEvWAfPwgWO/cjp6oKjt+/w5nrBu2endMFhjeJN5LjtefPmPZIKIeW20xjPrbZn1facnpyxHRsuxpYxWqxR+uBYtT1tMxGTQVUQUd48uc+Nt+4gLtJ0uazadqA7PQfgpBlYOXhjdU7bTKwuTuijpY9ZcnmzCbxZ6qkIrPxIVEOIhsFaGpPoo2VMhs5mkWd3vMa9tUZutpjOwTji3v0WbtnTr5eEaLEuokmQI8WfbFh0A8PYsFytad6+hxwb9EH5YyvlP9DN6Yhf9BhROj/RNSONH3Eu4vzEODToHcHQ4ZNh6acsYV1saduhCDnjTngL0AdHTIa7o2XZDjRNkYEeJ3w6Y9kMhGRpuoEQXO5nuoHjzRaRLD+1ooRkeGOxfahvHkt7nZIhJIMznjE13Bkst9vAqtvibCQmw9nYsjheE0ef5b1JaU4ucntfbblxJ4siF2PDyfE5bTfQNgPfvDihNZGb3Za3u0hIwo0mln4sYUUZkyGoFImtxYpBMag6ltaw9CPdG/eRt4+wXxtYLrY0y57j6YJp8pyW+2maEe8Cpzfvs7h9H2kTnCxxccPyaMPy3kA3dDRWuNFtWPmRxBEnzUgfHE1wqMruT2gDezku0NmANUoqIkhVobERbyKtDTQuEqLJeV7kpUNwTMnu+rq5D81/vtc/PCuVSqVSqby61CUVlUqlUqlUKpVKpVKpVJ47r80Mh0qlUqlUKpXKi8PZE76v/UP8QPcp/sR3/zZjvM/xnzsmxAcY+eksfCyc6T/iG/xdDqfbKjxl9q1eep3fxyvO/bBcTsiHmQ30pGtf5VlG103bdc97Ujk9afp/5OGp2YkXV+4fBw6Fm6/ykp1XkZeVZ69iGT2Pfuv53Fed4VCpVCqVSqVSqVQqlUrlufN6zHDQ8tQ0AV1D+ux3Yu7fxXYjN2/e52x9BOT1rkdv3sN84Yjw+e/Fp1/n9Bt3GYaWpAZnIqcnZ3Sfex9Ob8G9+6S1h2gwPuT12snQquD9xKLrOX3zLs3xBoB2vcCYxHboeP/imNZNHC+2rJZr3jm7wYmPLF3g7bffo/mOB+jnvwPZrGnP73L7jTu8fXaKbFd0NrJoRpyNrLqe1Wc+wLQjJIO0ec318bufou2G7K4IdpcVrplomwnvJ4wLOBfo/EhnW0LK69E7GzhZbPIa86MN9niLtAl3Y8PxrQcsvz5y5PJT5ZWfOCrrvrt24Pj4gtXt+7hlTxgaxmm/hv7GYouqYMdEExydC2UdsRCTcF9aVAVvEjfbnoSw8iOdz06DZTPs/Amtn+j8yGZsicns1jhbUZqQq6U3iYWbdmv3t8GRgDQ0dDZyo+3xpmHlR7ZTdnJ0NnJ7scFKwpiENWnn2ei2gSnlvDSiNEPLIjrWwXGrGXA20ZjAUfBcTA3N5FkHy6mfuN1tsEaZomEbPOvgMKKs3MSRKB/0DRfBsXSJk2bESl5bHlWwoogoQ3D0NnsAvElYFbwxRAVvlDHJbnwg6uxogCEJRqCPYC10FhqjaDlHJau6EkJUZUr58xkj+fmkAqp5PGFKOQ7Iz4GTghdY2Mitbstx23NydEF7vKG5eY492mKOI4t4hxQN6/MjnIs0t86wn08cL7/Gp9+/RYiWb56f0rnAwk+slhsW3/Ut3gTeeP8tzvtul/+3Tx4gkrhxdM4QPE0fMShWlFu37nHzM+8xTZ71Zsl2arKHRRK3btxnebTB2oCIYk3ijTfvsPzs+5jjnu7+MnsHjOKXA2KUt48fcKO5TUiWt04/4OjOm8X/YVi4xKmfWPiAIZdVYyMhaXZvJENnI4nsD3FGcSK0tx4gby7h+IS0PALnMYtv0bi7nN69S4qGbtEjLoE32JMty9WazXbB6o37mM/kOqtxIg0NaXI4wPrsSEgqrLotp6dnNO2Ia0dcMzFuW1Iy6N3brKcmr/33EyenZ4RSL70PWBvolj390NJPDQ+GDm9avA107YjrBnQEc5xYLbbZhVPcEQDGJrpmJCaDIXs3fnvb5bYlipXEGB1WsmcgltpryP6VpTPZU9INLFdrkgrvnp/SnZ4T+xZ3soGo+FvniEu4GxfcOF9iTGJ9sWJ1ek53sqZZ9rx9503Oh5aTxYY32omLYHf+hs7mvmxKBgMEzR6OpCAIIoIBnI34T1+gx5/Fn3xA044s376LsTE7dEo/5FzA+YmjT93Fn2wQB4QIVuhOz5FvZCeMt4lbx2ds+44PNksMuU1CdjZ4svMlquBE8SbRmL0czYjiJBHU7PrFqIaYlClZvMkuh6gme06iKecIqTgiZgdEpfLsXC1QDPEeX9r8FF/aCD9xF0RaBIvgiekBj25zOI9bHYr/DIKUbS/nz1/F0b+PM8+6reKL7EfkGu8P+STUlaeNwF+Wcn4c8+p5zkK4ql5dV4r4vLhuG/qoyux5temrJL/PTp3hUKlUKpVKpVKpVCqVSuW583rMcKhUKpVKpVKpPCcuj7IJ3r3Bl3/ou/js7/0yH3zpi/z0L/0+fuIbPb+4/evlfFu2vSxjVZp2210+PFoZX+tx148Hz1oCT9o+9KrRzcvvL193OezL333Sa8hHu37+1eR53turkE+vQhoOeVH5++2FW2c4VCqVSqVSqVQqlUqlUnnu1AcOlUqlUqlUKpVKpVKpVJ47r8+SCqdoAu4NmP4r6Fa5/9XfxfnZMZuxpY9ZztfefkD89OdJyxP0zbdpVluaZsRsF/z/7L1ZjCVLepj3/bFk5tlq6eq+fe/M3DvDGXLo4QKTNAHJK2QTtiCbsiVBoq0HmQZIGbAkAgYM2KIebD/yxYYN6EWETIgGCIM2KFMWbHkBLdGmFnrooUDSHIIUh7PerbtrOXWWzIzND5Hn1Knq6vVW39s9Ex/QqDx5MiMiIyOyqjP++MKYwHi6Qs0iuJ507onrCQC6ctTGYweRlwziuskn3kdPWpLX6HlHDIrJ+ZSz9ZhKew5vHWe52dc+iVVZIrj3xj146zXiwW2UscjdJdPDObOmZekqUso6pZHtmU4WVG/OYWKhUoBlxPvsf+lNqnG7vXzRAWUFZT226tGVQ5mI0pHaOKZVTx+yaGxWt0zGK6rpCr23Qt1KMG7AB0YnD7j1pTn75/tZ6GYctXFoFRmP1uy99oDxZ95BjSLRGbzXnK9HtK7iYLREqUjdjlj1FUZHjLpY0kirhA+KSgduT8/xQdPYnrrqEUmMR2tEEkrlbVv1NMtxFji2DSJZ/Nl7TRqUU+Oqx+pA5ywuanzMIrqjuuXu7IzOW4wKrF2FVhGjInf2zrIwr75YvqtqOiaLCb2zpKTQ2jNbj2md5bQdczReMLI9dd2xXI85W48ZdQ3zvuL2aMXrB6dY42i7mmXXMO9rrIrcGq2wxnO/HbEKij0b2KvyfTM6CyuNCmgVWfUV567KYkwVaYMmJGgHGZyLgh/sjm2ASuXPXciCx5Sy7FEPDlGfBBeyHE8J9DFL5FY+iyV9kmFfPiZvJzRCO6TpyM0uJTAqi+1G1nEwWdKMWuxkndvQ6xrGEyxzmq5icjbL93x/DYe3kUO49QfvMJ/PeLCaoCW3jdFkjbwxpl4fszdekpLgg0YkcXh4inOWqfWcnO9hJGUhpvY0kxXjT77L3oODLIBcJXzIFz6ZLZnefUCKWZgnkpjeOca8voI7e6j5gun6QZYwzpbopssCTBWZjZdUdc/IOKbWEZJQ68B+3W3lh1aFoa41IUqW9gFpEAD2UQiJQQZZ4V/7BKlqUO2SNJ0hkxOq/QXNfIoyHt104BPSJHTlsMZR35rD4SE8eABeiM6QvMrX5BTBDfJH4xnNltTTFbrpUNbD6YzReI06zfJGowOjqmO0v8D3WURpK4epe5q9BXuLMbZt2FtOmZlRlmLWHabpiecWNXM0TUu19GjrEZUwlSNFYTY9R6lA4yy2r6n0/lYaGZPQhvwrZLPdBs0qKNqYw2e1JJQKzF6/j3OWkXGYcYuohBo50IL6hKE6m8N+zXh9j+gMoiL1dEVz5wQzajkYLem8QanIaJBExiS4qLbbfVR0UZg7TRuEpQcfEy5G0AqtInzsFvHWa+hb36CqeupPHKPrHmU9bt1g6x5d9+hxR/36CaiUX8svO1J2B9N5S0iK/WrN4eEp/t5ttMry3DYY+qCzrBboo8JFhU0XQs0wtNld1V4QQUWFCPjoYWhvLipc1KQEfcz95tzZrdgzJnnpgjgLLwNPFtIJmrT9TZunRXh/wrf/4j34RQF+C/gtRPRWHBnTkoRA8lfy0uSWvAmbV4joYcrFRhz5qPLc9PJ1jxLFXZfPs+T9qGOfVc74orm4B5ldaedV4SeXjt1Ol0m7AtAL0nDu5t4+tH8rCr3Y3t33eOI1Zb7I4ZuPp2l7iou62GzvjhPv1tOrWEc31fcfbssPc5289oPkf/XcZxUpvgzyyptit20+epnbEuFQKBQKhUKhUCgUCoVC4cZ5dSIcCoVCoVAoFApP4EmjZ4mEv3SkYPj+0Y/wmeqAX1z+D/hwRkqBlPqd4zZLdF8dWb06qhVIabPvuiXqNiNimwWbb5JHpXfd/mfJ+0npvqhIjedJc/eeXL/86eXteLEnXey/GrGw/byVhaor51+MYW7Ou4huuDo6f3HeRXkeFwlzUaqHy/8y8Kz3/2mjPq5ufzNFf9xU2Xf74PXROR+8/z/p3MdFP91Efs/C05TlWc991HKYm2eN8LjoBigRDoVCoVAoFAqFQqFQKBReACXCoVAoFAqFQuGV5XlH1/NSmP/m+M/wX/3rf58vfqnlj37+r19xL+gdz8NmlPq6ufZXR78UShoAUuq2ERWZ3ZEwuZLek+ZYb5bmNBcuCdmUKV76mT0VgZQcShoSLrsHRJFSyOkM7I7kI4aHR0p3xuceyvfqPi7yTxcuqct5PFyG/OXOn+XJgygEu01bUCQiKbmL601+qN+H60akHvIOyBChkob6F7Gk5BCxwz2/qJ/s4bCQ3EXRxCLDcUKuo03ZdtvH9rp3lk9F7MW92eahL92nTXmU1KTh2jfXmX++iIiY5+Xq8qDP1/8un6cfcZTs9Ee47HZ42oiPlzUy5INw8ex4vCskP8eu9zh8kLzh8r3Y5erz6HJ5lRoT4+KGynK1XJs2ebVsj/NbXBd99PAz9eHvnlQPF7waLxySkHqdn1OdhfOImjmqccvy3busXX7gaRVRtSNOD1HtAlktsTOHrRxKElp7lApQKzg9J9wf4xcjxESUiVTGU+mA0ZG66TB1j3ltiRw1pHstqq3QJmCNx6qA0QFrPfX+MovYBuGe3VuRxrfR734Nzs+hd8ggOttI7rTKN0YkgRYYj2A0hhhRk/ex1mXB3umU0NZEpwnO4NYNwWtCb+nOJnRtTUwKqwJWxaH8gbrpqA4WqE9PCW9+Br93GzO/j13+OvsHZ9w+OcJHxcFoyXScbWiT2ZLR3WPUW2PwnurojOZkj0ndUmnP3mxBVXc0y47z5SRfs/XEKGgdiIPgbGR7bh+c0nYVo6ZFqSy3HE2XxKip6o56vKaerrDH+9v6sNqjdaR3hjRI1kZNizUe5w0xarresnaWW6MVR0fHBK9JSWi7GiUJkcTBwSn1eI2te1ISUlTYcUtV9XRtQ4wKbTx15eh6i1aRo70zZnvn2KZjupgwms+oFzNGpuHOdM7t2/exow63rlktJ5yux/RBM6lbZpMlR+d7LL1hzzpmTZvbokRiUlTGoVSW+837BpeESgf6qC79qaElC5bUsDMOzyElWfC47Q5kwWRIedvHfExMF0LJza/lOIgmcxqJMPyeV8N3ZsjLKGh0pNEhyzOrjmaywh7Ns3T06IhkLLJaY8YtxgRiUOAFupY0mVHfecB4tKbSF39Mig5gK9RkhVKRcdWxdlW+t/sLDm7NCeuKdt1wvJ6wZxuMjjR7S9RhwNQ9Vd3TO4vuIjpFRAeqozNmUQiDNLA6PIfDMWm2j2iDPVjgz0e5/mpHM2qpVK5E23T5/pDQkgaRpSKpLOEDCEnRekNIQhs0Lir6qLbRpkogeQVmkCZWI9RqjvQdaZmILu9PQZGCJq3zidWou6gX7+HcEZYTwqomBo0apI0pCVZ7jAnYUUvz2glq1CGjQAqa0XJJYx2rPtel1iGf6wxa53qrpytGn3yP/fMJ6nifw/GS6WJGXfUY40lREBWhF6q6z6LPJgtpAXxboXTEDPdzlIRm2O4HOeLS5f6TkrD0hjYo2qBwUdACVqX8LB23TA/PGH3doSct0RliZ9DRZ3lmtcjPvrqjmq1wXYW2HlV5zHTN3mzB6XpCXfW4JFtJpE+gBulqSEIXhTYILgopgVZQK5V/GpfzmB+T+iwKlolgmwVIwp5PMLMlqvLIyCGHQjpLpEWWk8ZlBVERoiKknKc2AaUSLipCFNZBs/AaqxRWEm3IwtEuamISvIrEJFgVCcN1bH536UEkmcudCCRWwQz55evVkvJ5w/UqyBK/QqFQKBQKhZeUMqWiUCgUCoVCoVAoFAqFwo3zakQ4FAqFQqFQKBSu4WnDqXOYvNUH3G2+iz8x/Rzfvb/mq0v4c3/rB/lN+QKgdsLjcxh3ujQ2dTVs9mpo+ZAPsg3RT4+Vie2Gij+NiG2YmrAzpUBSHMqZkB25XsJvw6xjai+mhqTd64pX0lY7aedryexOKRm+S9dc186+y6W/qJ+0c1y69F16OM0Ucj2yWa7yutDlTU4hRzztliFtllePD9fuMN1jd9rHxTWoK/s3nzf14YacN/XC8J27yCft3Ntrruty6S/yC5t80+UjXi4eJeB83jTg4alGj0r9aeSaT8rrm4EL0eijI/0u+sbN53013d0yxGu+v/gc4/kNl2dD2vm5kTnu5v2oerpuOsTF74CL8+FCzrnbpp5cvyXCoVAoFAqFQqFQKBQKhcKN88IiHETkZ4AfBt5PKX3PsO8W8PPAp4AvAz+SUjp5UWUoFAqFQqFQePV41HKGDx+TZXs9m1Fyow8JcT2I9jYjTxthn0cpQ0iOn5v/CrPFHY79V1i7+1RmfzjnIn1BI2pESm4YLX+U6O5ilHsjRcwlT0Pe142AySAMvDpS9igJ36ZOruT1GLL4cCMgDFxEX1z8vEjzYnu3XLKNTNgI6nS+vo38MF2MDl6+lt1Rw4207qpw88nSu813F2W6KnHbrdvd+s/SxcvXeSVN0TvnaUQMaRuVcPn6dmWTV/c9XGY9yCUHcSibdnUhiXyojtJlmeblJTVzKo/mWcWNL0Ki+CxpbtrDVUnqLs8yJvy4EeaXVRj5uHv2NPfzccs1qp2jdtvS1YiE562Tq3lf7ZO7R27676PKcZPsludJXCfGfVQE29Xt6wSSjxdHvsgpFX8D+KvAf7uz7y8Dv5RS+ikR+cvD5//kSQklIDmNqIja65BP3Qal2Dv+Oh/rKkJUfGM5ZVJ16Dd6utufxb7/RVAKVTuM8dR1R105moMF7O/BcgmDuDF2ljSIx6yKNNohkqhnK/j2jxP2DtDV19BugT6dYoxHqYgxnvGtM5pPvs/BaMVxO2JWt1SfXeFu3cW+9zbpvR5pErpy1MahVSREhQyCQ1M5mNZQN8Tp3iCNvMdk/xw7ahETEOuJbRaWiSSaUYupe4I3dG02ENtBeFkN0r/xbIG5syDN3iQ2E5Kd4PcN+mjKeG/B/miFUYGD/TPqJoevNfvn2M90+M/8APr+O5jF15ksHvB6b4lBsfexe6ja4Rcjlg8OcL2lblpi1NimY3x/zbptGI/W3H7rHfrliGqyJiVB6YAed2jraQ7n6FGPHnXYyZrJ7VPG795mcjAHsqxOdCR6QzVeo2tH6CyiEu35hLpy7O+fcfdzXyJ0ln4+JTjD5HRFDIo7n/0y5mCZhXgqkXqDVJ76eIZfNaQoKBMJncWta2ane+zdPqG+dYaZrZmdj9h7cMD+gwPWqxG37t5n71NvZ9ldZ2nfPWJ+PuVkNWV/ds6dT7zLfDnFJ8XE9hztn2Yp3yAIrZsObQKL+QwfNHo5RQ2ywoXXMUuS4gAAIABJREFUKGEr2VOy/ROSWidsgkoJ5w6Uyn5RLWAkYQR8ErTOAsjNuUbyv0plwVwCrIIQ87FaYGKgDXm70TA2kZkJTKue6WjF3sGcg09/A/2dE8LrH8cfvYVePsB4hzl/l8n7p4TeovZDNmf3Hea1lslsSW0ubOSmcsTbr6HO5jR1R0rC2lVoFRm/cR/5k99F8//9Oq+tG84WMx60DdO6xc5WMGuop/mexqDo+wpxielrJ5jXWvT0Pex0Tegs9tMr4t1Pk5oxKkbU9BjVG5IzxCgY42l0ZDIIUn1QRAQXFVGynK/a+aNRSf6lEJJs/20DdTfiyNqBB/PuV9HjY8LeLZKxxKWlPx+zXo7QJrDnB0tnL8Sg8rPjYAVmRvKQnCE4Q+gtpqlyulHQOjKZLRjdPca8uYa9CUym1OpdojPM3lvSDtLGyjrMqCV0FmMdpnJU+wvUp8bs+6/QvHsLgPcXMybTJSEqlImo1wV6GB+cY96/k6WR4xyCm4LaPutk8+zRAasjC1fTh/yHaogKlwQlCTW0TasSVgnNIIyt7p4RnWGvWSE2iy/VyJE6kBiJd15H3XsXAN10+bkIJK9RlWcyW2Du36auO0JUrILaimXVIAONJJQIjc7lqLVAEBqtGGmhqnowBmnXxE6jdITDfdJ4gt0/wT54Hw4bMBZUDas1ca2J6wo9aUmDzDYLHiNGZaEnZBlwIEsgQxJSEJJKaJXQw/eQxbCbYzbCyAT0QV9qc1ryn/x+EEbGHWmki4ISwad8bHrZ/oYsFAqFQqFQ2OGFvXBIKf1fIvKpK7v/LeCPDNs/C/w9nuKFQ6FQKBQKhcLzICJvkgc/XicPwfx0Sum/frmjLp/mTdJgAEj9pc8+nLKJKhBpeH38zzDhAI1hlMb8q4eH/PFPfZXT9Rv8b9+4w6/OX+fX099m3b/N1QiDhCddmm/8uHnn+XN62uKTuLxc5qPy2N2/m1+4cqTsfB5GHzeugOTZXNfuLOfL7HoF/M72NaV7dCKPIFz5eXn/45J5mvLu7rtc/9dHTmzTTGHnuGsySbujuHk7uxYeNbJ8tcxuZ8+m/h8z4p4e+c0TeBmcBs+S5nX37mq0Q3zEd8/Ky/pW+mla/dOcf92xF9Ejj07pJur0asTCw/f1mR8VH4gPEkHxLOeEa7YDj7vKD9vhcDel9A7A8PO1Rx0oIv++iPyaiPza/eXL2lkKhUKhUCi85HjgP0opfQ74w8BfFJHv4iLq8juAXxo+FwqFQqFQuEFeWmlkSumnU0o/mFL6wduTss54oVAoFAqFZyel9E5K6QvD9jnwReDj5KjLnx0O+1ngT3w0JSwUCoVC4ZuXD3tZzPdE5I2U0jsi8gbw/tOcdClIrlPIySnEyPKrbwGgVczuBevAaDAN4h1pPEXqE1IS3DDXGYDzBenME9djYm+3aXfObucli0q4VQOqQ7yDGBEbsdM1zailsY6UFLp2yJt7HO2d8f5iRm0cTMeo1RxiQppcdjNuqaoeEbblSMO8Z3oPfU+qGtRqAdMR46MzRGd/g9GR5Ay+rajrHm09ynqiM2gdsdpjVKC1FY3tcz4qkTqFenAPe36GjREm03wdkjAqUNcdo8kaZTwiiWp/CbMpsZmiqho5mFDdPWXmDNErmo/dRyaBqlOYcUt3OkNXjpQE0/T4rkKbwGi6pD46Qzcd9mCR3RMmgI4QheqNE8RGpIJm3BPXlugM4zfuk6IirBp00xHaGlX1qNrlbesxTYf3mvHeAnv3DKtAfcOTkkLpQL8aUd09Q+4YQGXxwaqHSmPUOep8mBseBd2YfP8k0dw+Re+t0PsOGTlS0MSg0DowOpyj99eoW6B8R+1PmYxXzNfjfG+bjqbqMRLzHG8d0CaHGFnrsKMObTxVVzGuOqp2hJKEUREjkCQRJc/H3jgY9OBg6KMQUv4M2dNQqYRV4CLUKhET2+N8yoFkVrE9ZuNt6FQ+XwuMTZ4LXuu83ajEyHhGxmGNx9Q9em9F2nuTsHebpHK/SM0YOWyoj84I63qQQDQkY5HDMeNbZ+ihHnzU+LaCmENTN94SH3T2W1hP/4kfRB+/h52sUcN5RgWU9TAaUx2eIyriuwq7cvTBkOKmMhLm1jkyH8O4Qc1PYTHPfWl4lRo6C0nhvcElYbkaUzcdS1ex9oZVUDQ6bvuiIqEkoSVRaw8YekkESagkuGHefR+gP5lhz96H6Rg5O8PMT+H8nLiuEJWIUSMhEdoa/M48fh1JTiHrFXgBlXJ/jSr7KPYTdtRhjcM2Hary5EZgCAdH6E/01KenVFWPVhEXNL3L16msRweNsh6xnnR0F62PGU3eY3Y6o/lavheuq/BtRTrx298CLhjcqs6OE3sRTqx1IMbsTFh7Q4gX/gGrIl1U+KgQsqNAi2w9FyEJ3muSU9s8wnyc2wVAL+Av8hIbkcHJkKLKzzgTsscjKlbrEedes/Sasc7PMj20K0lCG3KeLubfGquQCCm7TEIwcHYGTY3UAW08GANVTbrzOjJZkMZT8A5p19CeE+Z7RGcgCaHLZfZB03nDqq/pFmNWXc0qaGoVt+0jkvui2ngmhv69qZONE8QMToc+KmICq/JnNezfpJeS0EXBCqyCQglYSbRBPWY5sMJ1DFM9vx/4Va5EXYrII6MuXwUEcyHdE83R+Pv4Lz713fzL3/MbvPb9X0Af9vRf2+dnfv5P8Uc//xus+6+RQ2A3ArsNTyNre5rjPmyunfzwmM/fCjztNT9tePsHWQ7yww0uf7UpdfTBKPX3svFhRzj8T8CPDts/CvytDzn/QqFQKBQK34KIyBT4BeA/TCnNn+G87RTPF1e6QqFQKBS+OXmRy2L+d2RB5G0R+TrwnwE/Bfz3IvJjwFeBP/Oi8i8UCoVCoVAAEBFLftnwcymlvznsfqqoy5TSTwM/PaTzAYbOnm8ZNsFcI1e8iGzRao9J9TqtPyMmx09+7Ef4T//znyZ+dsHf/AuRP/a3P8Pv/cK7OH8fmAN/Y0ckKIhoUrq6RN/jKKOHrw5P2+YuiyEvtp8mjatRVqV9FD4snmc51Jtony9rlNfLy4tcpeLPPuKrH3pReRYKhUKhUCjsIiIC/DfAF1NK/+XOV5uoy5+iRF0WCoVCofBC+LAdDoVCoVAoFAofJv888OeA3xSRfzzs+yt86FGXzzcadhHdIIBCEBCF1bcwumHffJxFeJ9f+6Hv5Dt+quWv/4jj1l/8NOft76LU21RmHx+GpS1FQYpcWgIyuatZFr5peJ6olWd1X5RR3sJHxUe1HGpp88/KK/PCQY16xEbi2hK+phCb6BZjTh4csuiaQbiXwGj08e+hT+8hJw/wpxPO5zNOl1OmQSOSoPOktSYGjR53KOtJXmF0QDayrt6irUPOTsBYWLXgs+jOjjqsHv4AkLgVMQJZ4DVfoOt7pJMOIkiTJZSbY2ISwiBhA6DzULXo++/C+RxWHbrJ4jmxgbgy6KZDrEckouywbnPlmO2foVTA+3wrlYqMR2ts3WdDR90QX3uDsHdEMhXV73xhK4QzOlBPVujaoXSgOjoDc4i5/3XUe29D22cZmw5I3Mjthm42XE9KQvKa6BUxKNRGiBmzHkRsgBhhEMGJDoge5FSKi/2StlK26BUyyDtT0PiFyXLPRkhRoQZJXHIK0Yno8vdhqIPkFNIO9yclUg+sPXHZkKKQgoYohLYmutwOojOwGCEqEjuLXzX43uK9IfSWuKyQuoVe8vdB46ImBI1va2K8CCnc1IFIIkSFiZLvpYoYE7AqYHSkdoGJ8bRBY5XQBsGrLJRrgEbn+g0kpga0gi4IjU6DRFKwkhCBJiWWfiOey/+0JMYm+wYBap2llPm7LLLbiP42bVPvlD31BrVaYk7fJ1Vz1OIMmZ9myaloUhTiXFDmfWTcwGJN6F9j7Sxrb1GS6PsK9c6XicfQ9xXOWdYuf0dUNL/9vyMP7tGefoxl17AKmlVfQxQ4mwNjlA0oHXNdD/cqnmliNwhfJYEPMMhkgdy/O0vsLSkq+q5m7RWL9Rh9Gpn3NUtvaINiagJ7VUetPVolqqFv+6gZRYeRyCoYXFRbsWetNSlo0klCVAvTMZzNs4y2mxCDIgQFZMllXNSgI27dsFqPcMcz6tMzwnxEdAalA3bcopsuSxsHIaJr63x9I0uazgh7t1GrBSmusgjTGyKSn13Wo7Slni0v+ljf5SoyoHR+brTrJksgo9C9fQszXeHaKssnlyO09SSlER2ztFJHurbGDf2r0oFZ1W3FkSEpWm/wUdEGjYhm7BWnvdAGhesqkjO48wmrvqY/m+LWDf54gt5fIzGiFnNYrIidwa+a/BwIiuQVsbM4Z4kIq3aU+4eOzKxHb+WrCZ8k95eUpZW9EiqVRZIb0okD5QjzBtdVcHaGKJXbTdcifQ+uh7MV8URvpaNuPiEFRb9sOG1HnPY1tfF0bc2qr7MEVRIz42lUfkZtnvUJqFRES6LRnkqH7bN/0+/c7u+DoU+GJKiodvYpKhUH2SQYFbd9u/B4Ukq/wsNx3xtK1GWhUCgUCi+QV+aFQ6FQKBQKhcLLz7PMm3+W4xIQERlT2yNuV9/O96bv4E+91fHv/oV/xJ/8yR/if/mBn0HJ7xDTGkjEuKDtzy+SemR25e1VoVAoFF4MH/YqFYVCoVAoFAqFQqFQKBS+BSgvHAqFQqFQKBQKhUKhUCjcOGVKRaFQKBQKhcKNcdPLSw6uIwxN9TGOqk/zE699ln/lrS9zf3GfP/87D/jxnwjAXwMgJLeT9tPkUaZTfPPyrMtiPg8KiB/gfLhcxptaurBQKLwsvBovHExC3UpwsIfceZ04PSABr93+PM3/8wnG761Y9RXT8QomE+y7f5AlYG1HPz9gsRqz9pYm9phxC7VBvQ7N7JgUs7Q5rhUH03POu4bKZKmX0hF6B97BbIpMI/ZoxR5vs3+8T99nsSMxMp0tuDNZMBmtICY4nyMGUgtEiEGjJFEpTxBFTINUUVJ+TvsA6xW0PYxrqjdPkQo4nKJ7B77NddFUcHa6fbbb/QXNvUOS18zmU9pVw2T/nOrwHDWKkCLq9AGyWpDG022ViiSqqqe5fYau+yycux3BGKRd5+vuA5iUpXfOkLwmDYJMpQNiAlexlUPpiLI+y/Bqn8WQg3RSrbMNWwxQGwSPdCGLO50BiblOIQs5Vcryv6ARZ1DW5/sykJJs84IspUxek7qAZGcfREidIjmDanrAkYIiDEI+UzlCZ0lR8vlBbyVwG9FeWDaoSU88b/DLEXFHXglgrWNWd0zrltmtsyy8C4oYNdp6lPVUVc9kvGSvq6m0x6iQxXM+CwldytI9HxU+CWMdtmJDkYRViTYoJiZgJNEGvZXRAZx7TUjC0ivGOjIycVtHMcFcZRFnpRNWEjFplGQ5Za0StYpbYWLwmthWaADvEO+QxTz3q3GDubVATEDqCA5YrEnrlMWhkuiDxqqYJZRnLeFskgWjSbA64oLK8sf/431EC/MHB6xclaV/g9AQQE/XKOupzyYY47cS0+RMbi8bfMgWzOEaZeQweytU7YidZTResWcDISqct9s+0OjIxHiOxksq41ESqazfSkBjVIz7nkVXkxAOqo42GKwaY2dLqBLpzMPZHJmp3OeTIkWFtQ5jPXrUo/YGgawOeK+JfQUuoWYttnaY6QoANemROmLPJ1jrcjtyJvf/GJEY8K+9idn7CnXTMalbfNTsH5xRf+IYu7SIihfS1vMzUAps7icj41AqkVKi2l9Sv36SJasqYQeZoeiYJbUmMAZCb2mGup5ax7juUCoSo6K2jpiE1lW03jCJiskgl3SpQquEc5awrlme7NEHTegtpnKoUU9cVqgHZzCuwCfUxGH3lrmf1w496kASo/GK2jiURBodaVTkqGlRJCJCpQMhCgowKveZRmsqpVh6YaSHdhIhLm2u0yiwdrAfSVWNxJ0/mD0krxETgYhEIW37T8CqSGP8VvQ4MZ7DZk1Mgo9q2yfD0J5FEpUOaImEpLAqZOlsUoQohOH3QUyCkbgV8rqoEAEliRAlC2K1wao4SCo1Vj38HC4UCoVCoVB4WXg1XjgUCoVCoVAofEtw3Qiv5mjyT/ND5g/x733He/z2Cfzw5+fcW/19YsoDEiJ2WOIyXTov7++uSbPweF7mkfanKVteRnV3CdTHk66k+7TXv3lZe/X85+VlrfNCofC8FIdDoVAoFAqFQqFQKBQKhRunRDgUCoVCoVAofKRcnUN/MVIsGP7qZ3+UH/vxn+P3/+6Yv/Ir38Pfdf8nPnV5TugwIJzSdSPZgZQi39qjxpu6vG70/XEj8i9jne0ukfok8jKqT8fjnB+y893jtuXK/qvpXbf/ZY4iKRQKN0WJcCgUCoVCoVAoFAqFQqFw47waEQ5Wkz75FnHvFt23/YvY6bcRQ0tspuwdfoHZV79G+3caxtMlaTzBvf5t1P/wl2AdUTpkuR8JowJ63EIfSF2WNUoDHO2h2o47r91j3TaEpKibDjtuSW98HHnv7SyCnExgNsW+ecbsy2fMHxzk9IDpnRPunE8ZjddwMIPjc+KZBpOQmCWKdd3RGM/aW8JG6qYS1ArOHfQeQoKxQg7rQYKnwGhoarAVabqHjObQ5XwtCwBS0Oi6h3u3qEYdSgdSD3J8DmGO1AoZN3CygriPMZ666ag/dpxbQS9wuA9np4gPcO5IHpLL5UxJsmStz+I/VTtM02fZIsAgT9PWZdGiyteMSYPAONe3qrOwMQvwIuh8nuiQpY0qC+yUDmA9oiJhVQNkkZz1NLMlZtRuX5ep2qGcwdY9MShIQlqr/J7dRlKnieua0FWo2oGOECD6TQKR6A0paERlSWbyWfZYpVyXftVg1mv8YpQldk1HvXQolUcPjA7UxjEdragma0JvCc6AT+jKZQGlDVRNh1Ehfx7EchEhIlupYkwXowCVioQkVCpS6YDCYCVlGWPIkkir4iCbAyOJpCOVymJIgDgI6IxKJMAOskSrFArQkrBD+o3taUZtbkO1AzMlVTVqldsZKYI2yJFF0yIGwoNBwqgiSkeMjojk61I6wuEYeTexf3AGp/tMvGXZNVlu6DXRW+qmy/nrQGWyaJHOow8h9Y5mMcd+IwstlYkgidgbojOIidhuAVbBOsJIISNBeYc0HtX3VOOWkcnna+2xKqKARkeMioSoWPfVVtaXhpGYmITOW9beoobvrIpZ3Lm3QmqBSpPOPOkkkYJC6YC2Hm0CWocsZZ0IhMT41hn7p3vY/QXoLCbFBNTIZUmsAUSobp+yf7yHth6pHWkZkbMT1N4BmAqZCJP9c9p1g/OG0f4COapzvQFpGUidhnsLmOX7Y5p+kD3mfHXdI99+hLx9Hztqaao+37/pGj1ukcYjg6A1dpb12ZRGe2ISXDD0QW/lka03rL3FxQvxqZWEloQe0tAmIGTpp2l61MwRjjXpHCR0pJWAAjXu0Hur4bmQ23A9XVNpjx4kqUoSLqqtlNFFRUpCGzRtULRBEYZBs0bDzEasccgYWEOKivHRWR78e+8BUun8nPUBYiT1DM+p/KxLXmXx66Rlr1lz3tc0tr8ksAUISdEFsxU5uqhJKfeFjB5EtwkfFS7qbdlFEiHlOrASds5h+0zooyKSZZQCuR1LGR0sFAqFQqHw8vJqvHAoFAqFQqFQeOnZDTN/Fi6Hnmu1h0heZsmHOX/p936Ov/Qfe5BfBX41v/wVg5Kacf0mq+7L27OtuYMPZzsCyctpi1gESyKvGpWPu64cH+Sanvacq1NJnub4q2H7z1Ke6877IEtCPo7rlnp81LSCZ+FxYseNKBIEIRGekP7FsXljJ/A5xYt9aefl6ubz1f1AIm3T2mynZ+4LV6eBvIiXqk/TPl/kdA9Nvs5Hpf+sbeJVfPH8uPp9lrq/rq427ThyednWm1p+9bp+t8k3PmIbri/HTXNdWT4IV581z/e8LFMqCoVCoVAoFAqFQqFQKNw45YVDoVAoFAqFwo2QuPjT6vJIkOQ5Uzt79DXnawSNiOLjo+/nT8/+LO6vwc9995+msq8NxygSiZQ6Qpyz7t9GqRkiGkg4f4+Ueq4fjUqk1BPTkpR6UuoRsTz+z8GnlRQ+zznpyr+nOf7qz6vb131+ln/Xpf+86VxX7qvfP2/Zrm5vRiADEIbohielH4BIGo7PbcLlf9t9joQf/g3H4C8fs80v7mwHEn5bnjzauvvzUfuetU08D0+T9oschd5c53Wy2OtGkJ+lrb0qPK7cz3JNj2rXYWd7s19fOe95uS6tq3ld3d79/CK5Lv+beI49zTPx0bwaUyq0JjVjkrHUv//3kP5/RRmL/srv5+8VaB1ZL8cQH5DshPC570F/7UuIjigVCUkRk0LVjvi5fwppV8jiHGIk3n4NdXqMHXUYHVi3FQ/u3+LNW2fE8ZTwvX8IvTghjveQvsXwTxBJOGcxt5akO59m9MbbTO8d0rU1af+Q+Mab6N//XWg9pOwfsHWPi5qlq1i6iqntcL2FvSlMI6zaYcLxHnGc584D6ON7eV5xMyIc3IaD2+jj95DFOcmDqjzontjZ7B8YHAtypyZ85juJ4z2IAbWaoxe/DWTngKn7PKf5aA/uzbMvYjSG4MEHpIuIieg6h1tK5aFKsFSg4uBciASvEaPx3qCNB5vdFHrU5XnpIwNrD7VCmT7vG9wNhERc15CEFIRt+I/KDVesJwad59ZHQQaPg6hEag3SePSkJQWNXzcQFLE3yDD3OswbkteEVUPobPZKREFMyM4GfdnqHd3lLiHD/GhR2RmwIQTFqq/o+ooUhRgVLhics0Rn8L0l9BbRAaUjMrgegjfZXyCJZV9z1jXMnSUmIQI+Kroom2ZNv/2shuoS2qhQUbHwCiMJNxy/DHnevE+CIc8Hj0CIkue6JyGkoepDnjceh/O7qAhR0CpircNO1qhpBzGi778H6xUYA6MxqaoH18Yyf68c8VyR+nyfeq9ZuOwNyO6PiJr0NLMlJycH+KDpg8YcLUjf9+2or32FvdU99t55HXO+R+csatJCbcBoZNWTgma+mLLsanTTofZ7tDOkpLCH57kNi4Kph95BBWIc6TjfrxQFHxUPVlNq41gFzXFvUNvf63ukJGiJTKwjkrezF8Cw9gY/1KEa7pO+08Pd2/n0u4Nn5N77cAyurVivRljr8MsGO70Ia0tJIbWDu0eIegDLiMwUTMdgK1AKrR4wPjlBdEC/pUhvfJr+tTfxh5+E5g7jd79GPV2hVKTrq5xwZbP3xQckOVAhP+HHI6g8ZrqmsY7FcsJ4tM5+hpNT2G+wkzUA/arJ1zHJ/VRknfvl4Lk47WvsYsa8r+miYtzl626DoQ0al3I9n/aaNgoLp1ksx6i6x46yd6ZbjLObwoB5oyPOc9AtJpG67E3IlSxEr7d957wbAbD2mtNoOBv6akhCrRIxwbnX9FFog+AitCFXyUgLzluoDfothbo3J3mVO8PRPtuw4L7P9ddEZBlRtcvPMeuJnUVXDh80XcguhhgUi77mfGjvc2dpg0ZL2joZNn6GWmUrQ0hC04dtn3SDl2H3uErFoe8ODh2yxyEkoQ0KkYRV2ZGx63wpFAqFQqFQeNl4NV44FAqFQqFQKLwS7I4sX5BHey8fp9U+SlXcrj/LjFtM44w/cnDAH3vrHWrj+M17HbOfeAMf/md8OL2UWkaGEen+EWV58mjao8992XnUSP91n58n3Zdx5PhZRoWvG0F/1HmPc1xc3b/xD8Cj58rvnrO7/2o+1313Xfm+GbnOIZB2vrt67NXjypKiFzypnW/q6bqlg5+Xq2k9rgwfxX36sAcjHn+NZUpFoVAoFAqFQqFQKBQKhRunvHAoFAqFQqFQKBQKhUKhcOOUKRWFQqFQKBQKN8KzLLcnxLgkxAXv+l/lHfIygr/Rz/jF+R9mmvaYJE9KkRDXXB0jEtEoGaHViN6/u01XpIHkB3Hfw+UQDCI1l5fFvOmQ3xe9LOZ1517HJmT/SUvEPe30g+vS5RFpXy3n1TyeNc/r0r7K7lSFTbmelIfKS1mK4uHrefj68pKq4cp+zfV1fF16V7f15eOTB1GktJFJvoipAx/1sphPWhLy6njw1XrdTGt53mV4XwZuqn6vq6+r3PRylFefQ886fn+TUzuukssjO/3+0UvTPu+ymY/qx49O79V44eAc6r1voETBgzP8N0bogxWx08TO4he3aLssThPvqH/v8/iPfRty92PY/W+QBpHZostCNLwjjqe5eXiPrJZwcsry7GOcrSasveXWIOLS77+NP/w47mhG3H8LfIv0a+z4LAu9FMhijhr1xCR0XY3cew8+OSV9/E3k5D70PSkK3XrEylmWztJoj4+DEC1G4htvkowlmYowu0OY3gE7BTuD9T3U8n2AXAY7g7vvYM6+TtX9I1RcAaDmHm38VnRIjEi7Qg31gncQEt1ixLptSEERzxQqzkkrQR6ckD75FnHvFtK3qNMHsF5hzheodY3UEZmoLKAki/hEx63QMSWh7yuqSTsIHkP+vbG/B/EUxg2yZ8D7LMcLHlbtIIIcOp9ERKUsdyTLGpUOIBf7tiRB6ggiWewmiRh03q8jMgrIIF3Toy7XkfVEZ7JM1HpEB6I3mKYn+iwVDeuKGBRxEMOFrsKMs5gyizITvbMsXUUYjnHesnaWsbf43hKdJniNGcSDREXoLX1X0QdDSuCiJsJWGBkGaVwa2l5IQkybnyn/apFEiAIqPz58EvRwu0OUvCz2UD0RtkLJkMBvt7Nozqf8SIIsjnRJEaLaSuhSUMi9+xBTNu/tDzLT8QypamQ8QbwjGYtaLUlfP8bOllQmEAErCdt00PbIKGKaHms8cZAzysentN/3b6Nv/wrjk19m+jufAbLQVB0k4ic/RWrGqNWC6r1vkBBiEtSoQwyoWYsOKvehtoPRiHR4BEqTjMmyyvHb8GCFqRxhR663qWMtCTvI/UJUBBGqmNti2PkjSCRjP1Y2AAAgAElEQVTBzvkiCUSySLPvoaoJe7fyn1z1ydBGqiwW7C20PRiNHvV4r5EqkMYT5A2DnA/CVltBVeVn03q1baus+qFrBNTqOAsGxxNSCswXU87WE1IUqBvSrM59vVkhff7PBHUD2qPqFa2zzJr8jNC3V7AGfIC0R9dbnMuiU2mAWY1MAuIDctZhTMjXQxYd+qhwSqGGtrpbNzJ81AJaB/Reiza5XrUJ6HGXG2g99GFADi3Se9J5n/OPwOacpkNLxEe9lapu8sx9SQbxYm6usNMPEhiByvaDQXKEvDXCLFegIN66jcQIMWQhat8hfYc+nKPn55sGgywi1f4CGcSsIgltAoqEGiSRbit5lW27GmoFNbS3LH7UqB3hYxr6uhrauIsKtWmXwzG7/7UJSVARksi2LRcKhUKhUCi8jLwaLxwKhUKhUCgUXjqujtI9zQjaZmRb8cPTH+ff+HjPH//Bz3P42a/gzyf8g1/+5/jzXzzhN5e/cCVK4fLoeEqBkHpCPLuUd0rtE3L3pHRVYHnTPO1I4rOOOD5rXYcrP2+qLM+b7k3KLR+X17OMoIZ81lMWJfEoyegNjra/8AH7p+2nH0X+myUNH8eLHCH/sLip+n2a+rpprvbpl+l+5PK82C4Urtm+PqJuQ3E4FAqFQqFQKBQKhUKhULhxSoRDoVAoFAqFwnPxfONIRt/iP7jz7/Bj3/vb/NY7n+Bf+x8/yxfbL5PSA1L6RR695NpHNee88GpwtQ08TZu4bonK63icr+Jpjnlan8Yu34rLP16dJnddfX0r1cfTsPEofJT1dN30xo/6Pt2EI+a6Z8rVY55MiXAoFAqFQqFQKBQKhUKhcOO8GhEOAtiKNJ7Qfe+/AKamryZI9Nj3fpfm7S/z+nvvcHrviGQsKIX9f/9BltyphAuGEBWV9qSgUF/4fdLakhqPmkSwQjwWFvMZS1dts60Oz8GMqX/578DIwtERqRkjiznt/Aithjdp796HqHFdhQ8azlrkH34RGUWoBSL0J3c5Ptvn3FW4JFQIRgWUpCy3+8qXSG98nKQU4nvMyTfypfctcbwHSuXt9SlJ6UEgN8/CyaUlriva4z0W8xmohH6wh9hj0u+/TewsAKp29Ktb3L93m5PVlFurMe7+HumegihU7hQVvoKevAuVhd7BssOf7uMWI2pAdS1x3RDXNd18imk6XFehvMH1FUoF2vMJ9WIMUbDxHF2fEOcCxy1qEgcB8QoMpBZiNyEMZRQdEJUI64qUcrl8WwOQgkZWgfZ0iq48uukwkgirhthZ+uWI9WLMaNmgB1lkcoawrhA1iC2DInmFdw1+lSWiWfJoCM5QpyVu1dAtx7je4p2BKLiuYmI9ft0QnaHrK5QkrHWkqFh1NW0wrF1F8BrvLOvVmNF4RXc+RlRivRyxXI1Ze4uWSEpsRXIbN3Qki/Y2WJWIRKzKbxKtJMLwdlEAM8jqAIxKNDpLKjfp7r5SNCrL7UY6EpLQ6ISWhJF8HmR5ne8tbjmiOm9QkxXsN1ks2LWoB+/D6XGWJXYttB1idG6fBnTtqI2jVpFKBarJGu7chpN7xKBw3qBVzFLBVUv9j38etVrg7k05XczwUdF5Cy4h7ZpU1SRjkNoRBpGe2EBcKsLpmLCuCV2FjeeoySnSnMLRHjIa52eBMWAF0/QYFVEkKutpdGBqIpWKNPpiJDEmoQ8akUFASJb2uaiyqG97jxL+nRqj3ssiwq8fY+o/IC0T/cld+lVD21dZVAi5/vqAri2j8Rq1l2BxnuswxtzXFitQCjVeQNsT3Si3y/sGOf4Kpv4SdiYwrmHVMX//e7m/mNFHk2WpSiEnD7Il8bwjtSBjgDPwAT/fp/OWynsOm1PkqCF822fRv/fFLJ0kCx/NwQpqlcvlA7hEchrvNVoSWmJ+9g19LA7/0tCGjYrUKo9ibdqt7Cuq/UVuh5Wj/tgxfOI2fP0+qVPQJ/AOqYVNZ0g9yEjlOjFZGDlr1kxNxEXZtvtA3lZJ0CpRD/dSDb3ECExMwFoHsxk8OIHKEBZjtOtRf/Cl/LyrLGKrLPCMMf+c1rDY1GVCjToa65gYz8j21E2W1eqdfxvCIIPdFT2KPDwisJHBbqSkanNdOzLIOPTNALgkKDbPgY969KRQKBQKhULh8bwaLxwKhUKhUCgUXlquX65RqSmCwpoZ32H+WT6jb/OTP/AlvnjvdT5355/wL/3fb7P2v0WMPSl1kHaXGRxWcEEPy5pdDRfe5KkRZGepwm9FPsoXcDe9NOHVpTM3+55mesEHKcPm1fF1Zbmu/T0qjSd9t8nnacK9y4vV6+9L4WF2296HUV/XCYOv67tPc+5HyXXPmN3PNyO6LVMqCoVCoVAoFAqFQqFQKNw4JcKhUCgUCoVC4QOhEAT+//buPciyoz7s+PfX55z7nJ3d1e5KAgmxCAmDwCCwowAGjI1CwKYQJBDzsE0wFE4CGJxQFMGVctmpJLhIwLhMmaLEyw42NhgK7GCEDUQ2hIdkBFqEkJBXSFqx0r5m53Uf59G//NF979y9O7Mzuzszd3b396namnvPs0+fPuf29un+HXGgHiW8dtL7MJSoyhfYl3+SfQifvTkJa7g2IilVFV5rOejFICQkyTa8lqAer52R/cjIpwQkRSTD+/nhPJEaqhWnflXbRj9h28wneLLC54HRngGywrTxeafa3lrSsVxPgfEeMGsJ7jh+bKv1chhdfjAIcLn1RqcNBqDF8gtLPW0k5YQnx+rjtIFlejSoX9rOaDoG04fzl5ueQnxl61Kvnq30NHi9nO4xnaocnm95c7qWy5ulch0Myul65tVy94nxwKgrPdff6N5o48c/bvS6Xe7+Of737FkPB2OMMcYYY4wxxqy7c6OHQ6Xo1DTFpXshrUPZx5V9XBFa/bXRpNbu4h8WZHGe4rFPJJs5CkeOg2uQutCS1Mlr9A/voH3pQySNHL/oQjAwFM0zev06pXdU3uF9QtWtUV58OWmew+wcHD2KlIeofpwyc/hxIW0OaNfJ757C+yQE/9o1hdteUu33aJGilePIjy7jwPGdzPTr9L2gKtRdRa/bCAHKZvvoj38UNpl5pMFSA1TXIaKoCmnmQ4NwP0HLhO7RabpHd6AqdOfbdLpNao0+jTLFbcuRK6bwF+3GLczBw/P0btnJ8YVtzPYaHD++nd29OrWd82jlkHaFn3foIai6Di2bQJOFg3vwRYI4xS00yWen6HcaLByfJkkrFhdbpEnFzPw0qauod1rU2x1cVpI0+3AIitkpkkaf8kiKpBU+T3G1knxmG725KYpuCPXmEo8kFS7x+Cq0h3XmpgBI0oo0LTl2bCe1rKAqE7J6TlWm+CJhcX6KoshoHt2BOE/ayCl7NcpeCEBZlQm1Vg9fOVzih9v1lUNicLvO3BRlkdLpNgHI8xqqSwH1ugst1DuKKkUEvHdUeUonr9MtU/IyGW63021SlglZNwSnnF+Y4vD8NLP9OqkLwR17VTJsIw3BCYUqBisUL9SdUqnQ95A5QDQUixjkr1QhGWlkHQSaE6D0jnIkbqQTJZEQiBIfvjshBkgUKu9Y7DdoLLapz/apbeuQXl3Btmk4egxme0AvPHzw4OdruGYBTiEG5JQ0BEL1KniE7uwUU+VhqrkmvdltFEVG4jzdMmPx1t10vpDS2JFy7MBPcHhxG4V3zPYa9Pbvop4/SNJ4EM2hd3A33aJGr8qoFppku+bxeRqCW04vkOwuYc9FUORweA7N50Ia+wk4ob/QIq8SOmVGXqQhfboU2K+qEnpVeOpYxDwcnHevQqEheGTd+WG7cTnXJr20B40a0hDo9PGLNeYf2s3Bhy7h8MI2Ku+4uNOAWgqtJlk1x9SBWaglIaDl0S7aVWRbCjt3hECF/R44oXbJTDhvVzQgq0GjgW9NhSCKD95PmlbU0gothbJfC/eR+R66IFRzLXyRkk4vInkfPJSdBqqQSLyxlBX5I55Ao7NAdvchsrSkLFJUJQQC7ZXooqL9hPL4FEW/RhbPXeUdfe/wRUbmPJV3FN6FgJpAIwlPpmrOU1UJOu9Jp7o4UYp+CMxb7H08aeM+3D0PhDJVEoKBLjRxjTyUp8Vw7y469eG5SGNAyjKev9wLiYTz6eN5AkgcNGMZH17LjSayC3T/TAhUW3dQKpQ59HJwnRB00wmxgEAiSFuglpJe3GO6vUBjfnsoFzG/elVC5jyLZcJi6U4I/Fr6UMYyCWPtUxcCtZYqKJBX4f4+uE4TF9b3unRND67dXjU43jCvmfgL/tnW1lGFczE8ISEGQ5rsQCTl0fXr+Jvrj7Dz0iN85ubn0ExLfvWOT1P52ZO2pJSU1cyqe1RK0BLV3nAKgGq+hvRudMnZzJI5Po76VMsst+xy81bb3ulaLY1rOYa1zB+dN/4UdaVjr5amnDRcu1xmF8tMW2sSV8pqjU/8teT87NEwbqPicFyIVsqvzYxpM6zJr/B3sy1d11uF9XAwxhhjjDHGGGPMujs3ejgYY4wxxmwJo+Njl4/sf/nUs/lfV17GS3/9E8hVl1J8/atc8e6rONp5ENWPIKQxzsPS2N/wpgldYZuD/drTT7NZxmNbjFpu+mDc+vgyJ7+95eT5p9PDwxhzrrEeDsYYY4wxxhhjjFl350QPB9/NKL9yiHTqPvoP72Th4V0A9BZbpGmJS6Z56OAlzHbaXPJ307Tv+RY+Vfx8i8UDF7PQb9CpUoqe4/47r+IxzZy01aPq1pDUo6Vj4eAeZjpT9KuUfpVwfLHNwsO72HPrrbAtjB8mTSBNkFpOrZbT6TbJH9hB1p+j6tUoipROr0l5hye5qIfvtylmpyg7DY4cu4jjeZ1KZTg2vFOlzMxu57Lb6yRtBVGkVoZmoMG/eoprh91LXoUhOR5wFeIrkoUCcZ6qV6MqE/p5jYW5bVRliktL6sePk1x0N8WhNvmxS5h9eBcznTbH8jqt2R1cdP8jmJpv4RJPttggm+4gWYnLSjwpeCGtFeRFQtlp4LKSqgxj3csypaoS8rxGDvSLjNIllD6hN9+m1upRdesgipaOqhfjNMTzqmWC+qX4FGWZklGEMeYJaJUg4hGnw3gOg7yrqoR+pxliPogiiafR7OGSEBtBAJdUJLUirOcdLnWktQJfOZK0otHs4n1CGY8nTSt85SjybFj2RJSiCN/Lfo0yz0JeJSU1V4ax/90mtaQkdZ7SJywstsnSkl5eo6oc3V4DVaGT11kswvj1SoVMPJkTMrf0RKBUoV8lIf2iNJKKdhwb74BmWpIPx4unVCrUXMiDgbxKcHLyE4JtaRgL3k7L4Xj7SmV4PhpJSa9Mmeu0UXWUZcqeWo64Pr7YjiQV6XQHSSsk80haQapIDbSnw2cXjSxnW5YjoszP7KD9leOor4V8TypcGdL24F1X0uvXqR/J6fXrOELaPMLsA5ey55IZpBHfQ++UqXqPbpEx/8AlbM9KXK0kbeRoleCPOVxtDqZa0M6QrAQP0ghxSVxSsaOWhxgCVUrmPK20InWeVlLSq9JhHnfLlESUQoUk5uPguk1EmcpCmVp4aFeIU9LuAQpJGq73MqFfZizE+B8PP/BIpv7pYdKL59CeoN7R+fYu6nuO41rDnYKbDzEcejk6r1RzU/g8Je13cdPHkbbgpubCMgt91Ie4G5V3zM5sZ/edd0HqoBRwHnEenA6DgSf1gkZW0C8zyiKje9t2Gkf/HGlB1d2F945ev87iPY+kXR5EmiEAiLQrEt+hvW2BqVoYG96rEurO42P8AidKzXkS50lEKb2jkQj1pKIoU+bveBQAiVO68236B3bRuONWaLbCr1AJ0grnC7pIPY49TEPw8vqOebY1ujjxtNNy+BwtrxIKFfJ4f/DxHlHF4u8RHEoz9cx32ui+g8j2ECMnbfdCoIRGCrUM6o0QV6OM45OLHDq9EBujVFgs0B40mj3aWY5XR3exxc7WInmVkCaeXpUgki7F/wAKWYorAQxjSigh5gQxzeIUJ0rlBS9LMVcqDc8AE1FqDpI4z6vQSvyy17oxxhhjzFZxTjQ4GGOMMcZsDfEVmICOvA7zsvYzaWib/7J3F6/6nc9w0//Yw963P5PD/R9QVSVJcj8iWQiMJw6hNhLgsTrFiw4Hwy9WWiIEqDzzrujn8lCN5V5FearXU57O9katNCxgdP5yQxCWe3Xeaq+0XGlbp7JS+hzhSdVq6R4fDjGeJsaWGZ8OJ74OcHSZlfY9mD4ov+NGt7XaeVyuDK9Wrlc7H5thPA0X2usvz/bec3rXSeKmlw3Ue2b7HVxbK6VnuVftDqYny6x7JmkY3fbWZkMqjDHGGGOMMcYYs+6sh4MxxhhjzJokPLn1Mi5lOxVKR3OeNj3FE7f3aKUl9y02+ej+ktf+G1D9LOBQ7QPgy8WlzZzGQ6nQu+FUzvZJ2bnxhGx56/0qyzN5JeX4k8bV3gm5lm2vtq21bAPW1kNg8Aq91Z6YrvQ0d9C7RsY+r/XJ82Df40/5l+v1sJIzKQdbodyf9H7Qkc/ncs+jtTrb4xu/Tk7dQ2l9ejcMtrfcfXe1V+2Ovz7zbNNw7phIDwcReYGI3CUi94jIOyaRBmOMMcYYY4wxxmwcUd3cFhIRSYC7gX8BHABuAV6pqt9faZ1rprfrjdf+LHmZcrzX4lC3Sekds0VK7oVEoFcJ7dTz+O2zcT+EoH7qONhpc7RfQxWms4rpWk4SAxXWkopeldAtU47FYIG5Fx7R7HPF1ByNrKBV65M4T6vZJU1Lev06D83s4mi3xXStR5Z4emXKvfPT5JVj79QCIkoWg/nlVcKDnTZHehk9L3iFdqq004pLGn2aaUk7y5ludEOgMOdxEoMfijLV6lCr5RRFRlGmlGWKc4r3Ql5mHO+0WMjrdKqUhSJDgHZW0E4LFooaIspCkZE6TybK0X6NmTylnVbsqhf4mA9159ndXKSWVKTxXyKeblGjV2TDAGdJDG52tNtClWHAvTIGgATYUctppgXtLMc5j/eObpnRyvJhQLXCJ8Nz3I8BEFPnqSWh5a/0LgSF8wmJ+BhQzTFf1HCiiCjttKBShyN8L3xC5ioy50ldFdZRh6DDQGvAMNBapSHoXuFdCGhXpPSqlCIGUyy8i8sJO+v9YT7OFRnd0rGzVtLOimH5ySSc13ZWDJcdBpBTYa5IRwJAVsM8czAMHtmrEhJRPFB3HgF63pHEgI/EZbtlSq9KhsH6HJB7R6lCFo9vEFAvcyGonxOlGYNGpqIxyF24FhpJhYjSSkpElGZasL3Zjec8BAhs1fs4V5GlJXmRkcZ1nPNkWUGe1zhw5GIOddo4lJ2NLiIwVe8hoiz2G/TKlG6Z0UhCOjLn8QhzeY3FIsOJ8qipOS7fdYSpqUV85VjstLjvyMXM5XUuaS/QrvdoN7ohaGmZ0SsytjW6tJpdksTjXIWqkGYlRV5jbn6KOw49gsI7GknFXJHRKROcwFRWsFimzBcJmVNyH/KvH/O8ikEIKxW2pRXTWUUtqdjT6FJPShIXgiQKSr9KKXzC8bzGoRgkdUdWctX2GXa0OqSuYqYzRbfISF3FjlaHdiPkcVmmJ5SVXlGjk9fwKjSzgsR5amlJlpRkWcGh2Z3cN7edvEq4tLXIxVPztBs9alk+vE+kaUmzEZ6udnt1vn/wMnKfsLvZYWdrMVxHhGvk/uMXhaCiWc7u9jxTrQ71eh9VQdVxeGYndx/dgwcWioy+FxbLhNILqVPqzpPEhwt9L7GcKo9s9tjd7JCIZy5vsKe1wHSzQ7vVIU1DWet0m1RVSqPewzklSUpUBZeEa6LbafLDhx9JXiUc7TWG943cOwovzJcJg5+ySoVS4/MHD4mDhlOuml7ksTuPIqJsi8febHWpyoQkrWhvnw9lPS2XgtMWKf1ug7xXR9VRVY4jszuY6bSpJSVeBUXoleG837/YYq5IYlBYHaal9CEgLEAqikfI/dLzq9JDPSH+loXjqLmwbN8LmQt56TUEnZS4zs6650MPfYJ7u0fWOtDbnCURp0INjU+oRDJE6lzavJbnN57MFW3PPxwu+L/dj8ZlTjUOfXQc8IlPeEXqiGSoFqgWrPxEbLmxxGsZ23s2cQ7WYjQuwFrSMRoHYK1pWim+AMtMH/3LCsueyuj2l15huhTLY5De8e2Oj+Ney6W6Uprh5DgJg+0OLL2ydek1qyutt3QsYYUUIYlbLMI8yUCX1lGqsIw4UD+8Dk508j4G04RsuO3Vlg3bV1YvE2cyln2t18hG/R9ppbgr49cDnFwGGJvHMtvZ6tYSz2StcTtkpNzqyNyla21p+vh98mzj3ix3vkaXOvF6Xz4d6+nE1yyfuM9R4/eXle4PKznxfri0foGqX/YmN4keDtcB96jqfg3Rkj4B3DCBdBhjjDHmAmY9Lo0xxpiNNYkGh8uAB0a+H4jTTiAibxCRW0Xk1pk8H59tjDHGGHPGYo/L9wMvBK4BXiki10w2VcYYY8z5ZRJBI5franFSfw9V/SDwQQhDKjY6UcYYY4y5oAx7XAKIyKDH5YpDPK99yh5u+Q/HyR/cQdWtIU55YN/j+N+3/yTvOfRZ+seOjA2BGB8uMWo08NiJQc9Ue6j21nAIywUvW0uVaaOrVSsFVVspHWfSxXj0GFYaUjLotj44D8vtZy3DSwbrhcCIGpfVk6q0owET15r2wXZHhz+MDiUY3ffo/JW2W8VPCSJJLI/jwR2X8l3jMAwZHlcY+gCg2sdJE8UPh1YoFWgcckGCcw0qPz9cb2kbSRxyMTIkQ/thOAaAxmCocXjGYNshzadTps+kLE/6GlmpvK/U9X+5+8i5PJJuPQJ6LgVmPDmw7mA40eiQh+WGO52p8aCQy5/PE/ewGa+xHL2uVzNI8+g9cmC1e9josn7k78rrTKKHwwHgUSPfLwd+PIF0GGOMMebCddo9Lo8e7W5a4owxxpjzwSSCRqaEoJHPAx4kBI18larecYp15oG7NieFZsxu4MikE3GBsryfLMv/ybG8X7tHq+qeSSfiXCQiLwf+paq+Pn7/FeA6VX3zKdax+sjk2H1hcizvJ8vyf3Is79duxfrIpg+pUNVSRN4E3EQI0/rhUzU2RHep6k9vfOrMOBG51fJ+MizvJ8vyf3Is780mOZMel1YfmRC7L0yO5f1kWf5PjuX9+phEDAdU9fPA5yexb2OMMcYYQg/Lq0XkMYQel68AXjXZJBljjDHnl4k0OBhjjDHGTNIZ9rg0xhhjzGk4VxocPjjpBFzALO8nx/J+siz/J8fy3myKM+hxaWVzcizvJ8fyfrIs/yfH8n4dbHrQSGOMMcYYY4wxxpz/JvFaTGOMMcYYY4wxxpznrMHBGGOMMcYYY4wx627LNziIyAtE5C4RuUdE3jHp9JxvRORRIvIVEblTRO4QkbfE6ReJyN+KyA/j351xuojIH8TzcbuIPG2yR3DuE5FERG4Tkb+O3x8jIt+Mef/nIlKL0+vx+z1x/t5JpvtcJyI7RORTIvKDWP6fYeV+c4jIb8b7zfdE5M9EpGHl3mxlVhfZWFYXmTyri0yO1Ucmx+ojm2NLNziISAK8H3ghcA3wShG5ZrKpOu+UwH9S1ScATwfeGPP4HcCXVPVq4EvxO4RzcXX89wbgjzY/yeedtwB3jnz/PeC9Me9ngNfF6a8DZlT1KuC9cTlz5t4HfEFVHw88hXAOrNxvMBG5DPgN4KdV9UmEtwO8Aiv3ZouyusimsLrI5FldZHKsPjIBVh/ZPFu6wQG4DrhHVferag58Arhhwmk6r6jqQVX9dvw8T7jJXUbI54/FxT4GvCR+vgH4Yw2+AewQkUdscrLPGyJyOfCLwI3xuwA/D3wqLjKe94Nz8ingeXF5c5pEZBp4DvAhAFXNVfU4Vu43Swo0RSQFWsBBrNybrcvqIhvM6iKTZXWRybH6yMRZfWQTbPUGh8uAB0a+H4jTzAaIXYOeCnwTuERVD0KoCAAXx8XsnKyv3wfeDvj4fRdwXFXL+H00f4d5H+fPxuXN6bsSOAx8JHYhvVFE2li533Cq+iDwP4H7CT/ss8A/YuXebF12/W8iq4tMhNVFJsfqIxNi9ZHNs9UbHJZrNbL3eG4AEZkC/hJ4q6rOnWrRZabZOTkDIvIi4JCq/uPo5GUW1TXMM6cnBZ4G/JGqPhVYZKm74nIs79dJHId6A/AY4JFAm9BFdJyVe7NVWBncJFYX2XxWF5k4q49MiNVHNs9Wb3A4ADxq5PvlwI8nlJbzlohkhB/4j6vqp+PkhwddtOLfQ3G6nZP18zPAi0XkR4Quuj9PeMqwI3btghPzd5j3cf524NhmJvg8cgA4oKrfjN8/RfjBt3K/8a4H7lXVw6paAJ8GnomVe7N12fW/CawuMjFWF5ksq49MjtVHNslWb3C4Bbg6RgutEQJ5fG7CaTqvxLFHHwLuVNX3jMz6HPCa+Pk1wGdHpv9qjJL7dGB20OXLnB5V/c+qermq7iWU7S+r6quBrwAvi4uN5/3gnLwsLm8tq2dAVR8CHhCRn4iTngd8Hyv3m+F+4Oki0or3n0HeW7k3W5XVRTaY1UUmx+oik2X1kYmy+sgmka2eTyLyC4SW1gT4sKr+twkn6bwiIs8C/gHYx9LYvXcSxk7+BXAF4YJ8uaoeixfkHwIvADrAa1X11k1P+HlGRJ4LvE1VXyQiVxKeMlwE3Ab8sqr2RaQB/AlhbOsx4BWqun9SaT7Xici1hABZNWA/8FpCI6yV+w0mIr8D/BIhMv1twOsJYyOt3JstyeoiG8vqIluD1UUmw+ojk2P1kc2x5RscjDHGGGOMMcYYc+7Z6kMqjDHGGGOMMcYYcw6yBgdjjDHGGGOMMcasO2twMMYYY4wxxhhjzLqzBgdjjDHGGGOMMcasO2twMMYYY4wxxhhjzLqzBgdjLiAiUonId0b+7Z10mowxxhgzeSN1hDtE5Lsi8h9FZMP+ryAie0Xke2e5jXeOff9/Z5eqU+5rr4i8aqO2b0oss+8AAAUvSURBVMz5yl6LacwFREQWVHXqFPNTVS03M03GGGOMmbzROoKIXAz8KfA1Vf3tDdrfXuCvVfVJa1w+UdVqbNop6zXrSUSeC7xNVV+0Gfsz5nxhPRyMucCJyL8VkU+KyF8BXxSRKRH5koh8W0T2icgNcbm9IvIDEblRRL4nIh8XketF5Gsi8kMRuS4u1xaRD4vILSJy28j6TxSRb8WnJ7eLyNUTPGxjjDHGrEBVDwFvAN4kQSIi746/7beLyK8PlhWRt8f6wndF5F1x2rUi8o247GdEZGec/lNxua8DbxzZxrLbF5HnishXRORPgX2jaYz7asZ6xcfjtIWR9W4Wkb8QkbtF5F0i8upYD9knIo+Ny+0Rkb+M+71FRH4mTv/Zkd6gt4nINuBdwLPjtN9cJc1/H4/7+yLygY3sKWLMVpdOOgHGmE3VFJHvxM/3qupL4+dnAE9W1WMikgIvVdU5EdkNfENEPheXuwp4OaEScgvwKuBZwIuBdwIvAX4L+LKq/pqI7AC+JSJ/B/w74H2q+nERqQHJxh+uMcYYY86Equ6P/1G+GLgBmFXVfyYideBrIvJF4PGE3/5/rqodEbkorv7HwJtV9WYR+V3gt4G3Ah8Zmf7ukd29boXtA1wHPElV7x1L3ztE5E2qeu0Kh/AU4AnAMWA/cKOqXicibwHeHNPzPuC9qvpVEbkCuCmu8zbgjar6NRGZAnrAOxjp4SAib1glzdcA9wFfAP4V8Km15Lsx5xtrcDDmwtJd4Yf5b1X1WPwswH8XkecAHrgMuCTOu1dV9wGIyB3Al1RVRWQfsDcu83zgxSLytvi9AVwBfB34LRG5HPi0qv5wnY/NGGOMMetL4t/nA08WkZfF79uBq4HrgY+oagcgPrjYDuxQ1Zvjsh8DPrnM9D8BXrjK9nPgW+ONDWt0i6oeBBCRfwIGjQH7gJ+Ln68HrhEZHCbTsTfD14D3xJ4Tn1bVAyPLDKyW5v1x339GeDhjDQ7mgmQNDsYYgMWRz68G9gA/paqFiPyI0GgA0B9Zzo989yzdTwT416p619g+7hSRbwK/CNwkIq9X1S+v4zEYY4wxZp2IyJVABRwi/La/WVVvGlvmBcBaA8LJKZZdafvP5cQ6yulYS53FAc9Q1e7Yuu8Skf8D/AKhp+f1p5nm8eO0oHnmgmXjiYwx47YDh2Jjw88Bjz7N9W8C3izxUYCIPDX+vRLYr6p/AHwOePI6ptkYY4wx60RE9gAfAP5QQ4T5m4B/LyJZnP84EWkTeg38moi04vSLVHUWmBGRZ8fN/Qpws6oeB2ZF5Flx+qtHdrnS9ldTDNY5Q18E3jT4IiLXxr+PVdV9qvp7wK2EoSPzwLY1pvk6EXlMHJLyS8BXzyKNxpzTrIeDMWbcx4G/EpFbge8APzjN9f8r8PvA7bHR4UfAiwg/uL8sIgXwEPC765ZiY4wxxpytQZynDCgJQx7eE+fdSBg6+e34234YeImqfiH+J/1WEcmBzxNiOr0G+EBsiNgPvDZu57XAh0WkQ/gPO6fa/hrS/EFCfePbqvrqVZc+2W8A7xeR2wn/L/p7Qsypt8aHLhXwfeBvCD0jShH5LvBRQvyHldL8dUKQyZ+M2/zMGaTNmPOCvRbTGGOMMcYYY9aB2OszjTmBDakwxhhjjDHGGGPMurMeDsYYY4wxxhhjjFl31sPBGGOMMcYYY4wx684aHIwxxhhjjDHGGLPurMHBGGOMMcYYY4wx684aHIwxxhhjjDHGGLPurMHBGGOMMcYYY4wx6+7/A3SsKPZPBHs0AAAAAElFTkSuQmCC\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABCMAAAGpCAYAAAC3XPzRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOy9W6wtSXqg9f1/ZK5ce59LVXW7feu2scFjZKTBI/CMEVeBMRKDhOdhQB4J5Ackv/DCwyD8hHhBshDiBQkkSwj5ASwGCcvzwGVmbDMz8gwSZmagx7KHxh7f2253ddflnL33WpkRPw9xyci11951TrXPrjpV/3e6eu3MlRkZ8Udk7LVjZXwhZobjOI7jOI7jOI7jOM5DoR91BhzHcRzHcRzHcRzH+XThgxGO4ziO4ziO4ziO4zwoPhjhOI7jOI7jOI7jOM6D4oMRjuM4juM4juM4juM8KD4Y4TiO4ziO4ziO4zjOgzJ81Bl4EQbZ214ely0BDBVFTo6rIysigpkhko8Ikv8DqIuHRIPZjNStJhJE2Gk+cFRjECvp1SsbyYRjylc6JDimxCxzTpMZQVAGAiHnyWou6+vp6iVSSrS+t0gksZAs5jQkMNpEkHzdZEaUSGQm2lLOTCU1LXnWkvLplWSzv//Zzuy7jWHdMUYqe6xdux5Vj6nX3aaRUzHiyfF9fmragBkiSmBgtBGAUfUk1XZoiQGY5RRSey+nelraW7GStTSCoLK2A4yWQr2WYajIpj31eTqXz2iJJIZYHycjlXa3cCRZLHFILf/bVFqOu5+E/D9teduyzdVaT9oKqV3p67agm3rNbVsYSrvUGqeTK9lJ+c9R349dPGsuk+WtGpfIQiK2+wMMs7QpaY7BB121tmTdxGF9N5e1plrTrNFa8y73xDq34+19Zre21+vf1U9sr7n2GHay7/Q6t8+/fX+v20ogWCDUOhYhyEmJZXtWzXW9x6LV+2wthQI7FaaQ9+zDQtBEkNJviYGAmbDE3HfOMXBMSiz3RzRIBtGMpdwHidwX9gw2MGmujykYoxhBrDWHxYRjVI6pbltrY0C5J3Ob167s5yK9lDa4SG6TO5t4PORfq6MY0YTr0qivObDYYRN3QUhEsNTSXe8auN0O1m2VKZcX4ZCuP6ixO39MiIgvQea8hpz7FOI4zotx32ezjzP1s/zpp/H6c/9Jrv/s0XP68eK+GBhm9tKfR16LwYhJHvNP7n8EyB8QE4nHMrXwaPnDcR9y0EcRDsmYysDC053w5i5/ML+Oed/7M3zlZuEqLe06T8LI5y/zB+HPX0Y+s5sJYgyaPygOYlwtA797lT8Eful9+P3jNV/WPwDgXfsDgow85rM8tqcAXFj9wJjTXYgoUv4gpgxbKHn4IX+wfUff5T2+ynV6N6ehb/D59N28JZcAXNnM1/Qd3uErPI9fBWBO1xiJUS9yDPSSUfLP9Q/ZgYkgY/tDUwgMtjaBVI4b2bVzTknl31CazlGOZVBkZiwfjoVAZCaQBw0GG7o/bnMasxwINnLDMyAP5CiBIGM77mhXRCsDPTYz6WOe8Fm+kL4VgM/tJvZhbfNzMsxgKfeJSv7D5ZCMY8rlOVjkmiOxxFpRAsoFI0t3g00SeBxyGQcR9kGYQsm/5T+MjtHatRYzdipcxdTOWcyI5Y+mUaT9YXMd87XftRuu5cBkOwB2DCxEriX/wfJH8rtcpa8zpytiOuY4pOuSh7Xd5rLWelRUxjxwozlda3/opM221EEEGXJb0Imh1OFOLhG01cdkF4zsiCyMJb+TTQQCn9PcLi9C4HLoh6RyXRyTtUG++od42SRZ3jeW2DwrAb1JqcXuJi1cM3Mog37v6Ne4tne5im/nmNjMEm8wYiubyojq2rbzQMq2TZslRLTdM9q1vfx+RCRgbVBwRCWgMrS2DRAY2ZV7c2H9Y7NG4mDPNscnIoGx5Se1tri2/zoI1VPrppbZSGUANF+n3kN1e7FDq+OaPuR+oE+7v+cu7QlP0xs8YQ/A02Hk0ZAHJGpKpZtt/e8U8mDvVWmSzxfjmIyruNbhXpXPXwa+92lux9/7xju8dfmcR/vcnnfjjIhxnEe+9n7uO3/v/Tf43eeXvDPnfL8/C88XeG9OfGXOcb7hyPv6fsu/kfhc+ia+a5/r4x97kvjW/ZE3dweC5ry8c9zxW88u+K3nuQRvHxeepZmZXICDzKgJl+x5rGOJkbQBFoDZEgHhq5b7r7fDV7i29/hC+h7+xTffAuDbLma+fhz44jv5rF/hH/KV+R9s4q4ycozPWMp9bbZglrA2yDyX/XXAZR142e++kOO/rOV3HorQ/Vw/xN33ge1F/hA8HfJyPhl82D9iXnTw4PSPi7vofzPHF8zXuTb5cWqn5+6507idi8/pvWlnfj69xn33sw/0vDo+6vbW/tIsr7Hb/6L5+qjah6Dls6kxYzazliMBipTPfyoTyQ5gy8kXcNrOEUL5Arn7bGqpHFM27eZD5dSnaTiO4ziO4ziO4ziO86D4YITjOI7jOI7jOI7jOA+KD0Y4juM4juM4juM4jvOgvBbOCAHGktWqygudWK2S6vx98qycucxXjibcRClCsXyMWZ4HPEqe+5magDC/PydhTgqaCNXFIYaKMZS5x1WfWH0IdZ69dvPTr+WQXQ5Furjckq2F5sGo1HO15G2QiYlxFcmZMNhA0JFB96WMC8lmUpkznywSZW5z6AGSRHZ2CXWOUE79bMzTHc6IRfJc5qXMaY7MLHYoErZ8TJCxzWfv49OnnUggc3NCGImZuaWRiG1efI2FEggMtwR8sZeQKhQ9BEGy20GhxW4igO2IJd1QZtmPooQqsDNjFG2egyCwDzRnBMAh5vpvzogEgwpzWvM2dO1Tz/yczFCUqfgERrJ0dC6xzRJSRQibuf+w+ghWOnGprPO78r4yz6uJPbVIFdfjVLIfonoJ6mt1HSjKaLv8SnFGMBIIzdVyOQgXXYwMIEIUGFt2sy9iKOHI96O09xfLwsjY+W+CKGrCYOV+sIFR9s3xUNuQED7YlHmGNQ7a7jmAxFaOUN/LLWUrjD1Ny0gtdoGRIOMqpC1p1b4mdP3Fml7ceC7qzzUNI2WJJ3GTg35bRJsn4jSv9WeVcKYt0aSkQ5H67rpDplDljSX/JT5NVilZVplMWx+8U2VU2Bf/zjQsTMPMOOS2vttll4SZsCv7Jo2EIp/M11ldI1OtJ9txsF3rr5Ikwh1j7Er1t+Q0tcla871nJVbREotEZlt4luq5q+cHYGZBEZ7r87xdxJS196+kbnqomm68H7Xvzvd5KDFczvh6lN4VkZHm+nBzpeM4juM4ryv+ZITjOI7jOI7jOI7jOA/Ka/FkhOM4juM4zsef0+94zj9leBu38H8yuOtZpe4ptfZkV7d8OWyWkr5v3+02pSf765OS4ez7+YlZPZN2vyCznLzWrWrU77lvNYpXwX3LEFZuf9eaVwcYaHGqTw7XJ09Lfdxa/lq0W37ZurjelUYs12+Lyt+Rf+eDOV3FpMb1Rdvcizw7WFdEuS+d1B33ovT5Pc3Paf77FZr68vX0T7rKrb5je+mBoBdtBb6gTxBR9sObAHx2+Ef5zviFtoz77+sfcSXvs9hhs0rjoBM7fQzApb7FVfp6W6J8TlcMMjGnax6NnwPg61df/MConMOfjHAcx3Ecx3Ecx3Ec50HxwQjHcRzHcRzHcRzHcR6U12SaxqpYGyWQMIJIEwQGgTltH2lZbH3Uak5ZOBhVmMvTModkzGZNSpbMSJ0IUcUQMQSQIlCTsk/L9qDK2An9BpkIjIy2a8LKUB6rGUoJgvWP4uQH5bIIsxPn2WMOet0EkIGRgDKplvcHDrZnZxcc5SqXUa4wlCBDiclIYMQki+4ARvZtP2QRYFbcbZvBaDsiWSKXpIjh2mNt25rRUoJesNakk91Y162fSzo7uQSyhDBL/WIps4KsadX4TmnPpDlW+5DFh+PJ40lj2QwKYxJi1xYMI6a1vCIwahaX1kee5pTTrtK+UeHRYEzd0N08wCFKE6LOSaha03qdZDQRY5VpJqPUKuwYwGAoeRskx6XKWndyyVGvipi0nnX6OCYn24pZKpLKIjtsjxeuj2j2QkwjIgy3RIaKorbuiyy5PTTJaFb+1dhqiVWVUdbYBJUmrFTJsRhPhkHHKoUVYUnCKMJVrAJaY7K1zi7skkRqMsAkM1GOJOuErQLW5T1vd5JYO//odLLYxWn7KGoqgsu0eUQ1lv+fS15XIWvq3hNTFg6b61SqZLIXVtbz63Zg3MgQa9rKtj8xS1AeITVLdD7VVrv9PZWqZbRwkGuOcsncRJmBaFkcWetsp5ZFkjEnPqo1IXB+vx4vTS67D8Jbu8RbU47B0/0VTx4/Z1e2p/0NqLE77JiXXNeXV5dcDpGblC88pyw2vQnCIRWZaBIOtieWMixEAmt7G9UImghqDCGXe4yJQa27v7Nosxfh5hh3vw9KDdV9A2Ej+VUJBBsZCQwl3UmNyyGxL/32xXLJLjwmFUGtdn11lGOpHEVlIJX+N1/u3COeNFmxP+zrOI7jOM7rij8Z4TiO4ziO4ziO4zjOg+KDEY7jOI7jOI7jOI7jPCg+GOE4juM4juM4juM4zoPyWjgjBAhljvsogohyGZRQps/ug7T5+JDnNk9JGcsc5oshz1MPdZUV8vzmSZVg63z3y6DsyxTsnRqjGKMmhuKICGIEMfZlfvujAd4cdizLWwBMsmewwMTIpYxdfqXl5a4FfhYzrMxZntJATG8RShqP0mOehJHHZTJyEJjniYM9JWqeo55CZEkHBs3z6HdcEmTESG0e+yATo03N3zCyQ02ZbNrkaWQgFQ+GncyjPsqMkVhkndNcPQKjbNMJxZsxnPERDKXp1XnXKnUpqs5lYInq0ggycmGPuLCJKeRj9qEsnNP5CJLR1XGuIxDG5v0As/xazwlizSUCcEyS67/OKRfjYkgtDZXsiJhNmMuk/Gj5vItQt1efRD1nSXBMMNRloZYd1ylwGYZyHWE2xcqJF3bJkUuSLm2ef0zH4oIYbsUrlzSgur2tVcatT+EEISASCDJuHATSe0xIt/whdf58nWufqK6AvD3S+SS6OfzCekxo9VC3lWPM9/Sw1FgqytCmzi+2J5G4Lr4R08SSsnug9yGcxgZWV4R07W2zTBedoebMCk7JIoNMzdlglogyb1wRORZx0+Ij8y3PQ++KyDEI7Wdpd+l6jG6WE8vHx+YSKV4JiS3d2n+clq1P59QXE2xEUZbmTzGO0Xg0SNffGspadzs1liTM1QOjub5zn5wPejQYb+4WnuxyPV3sb7i4vGLc5+3do7z81DgdOR5y3/Pk+Q1Pby5ZWh8dGFUBZVe8MdeLEpZLblLuj2ZLXGhgV4q418Q+RPZh4WJcY/XGOPHGWP0uysUiHIuH4ioOJDPGoEyl4eZ+vAu/wWzGOOf4vS0Dsxx5Q/e8ucv1/HSciSY8GXO6T+fHPNO3iKXvFJRoM0mX5n/IaXdOD8BsRppLpLYPaX39yyw05rwK7OT1dNlDZ8tpi73rO7H7lkT9OJtS7spb59Wy823k3JkvVtLT9Orvp/vaYvyAtM+/a9Vn8xLn/PFz33Xuvg8NwM7k3+7dvP3+5rNUWe5xE2s7e/17ruC8EOfi+kGxvOv906U87zrudP/L1J1xux97kfT6PnFdhrctH9s+B2TG8CZBd3x+/JMAfJ98B5+/DFyGNe23D8K3XBj/yKP8mesmBn7tvZG/9+w9AA5yw9P0FossfJN+OwDHcMTyJ3sAoi0EHZtL7kIumeXIpHsO3ADwnvzaC8TlNq/FYITjOI7jOM6HRUR+E3if/Gl2MbMfEJHPAP8D8F3AbwL/tpl9/aPKo+M4juN82vBpGo7jOI7jfBr4l83sT5nZD5TtnwB+3sz+BPDzZdtxHMdxnAfCByMcx3Ecx/k08iPAT5effxr4cx9hXhzHcRznU4cPRjiO4ziO80nHgL8iIv+XiPx42fctZvZlgPL6zedOFJEfF5FfFpFffqC8Oo7jOM6ngtfSGTGIMCrsilzscsjiwiqwnEIWCA7F7nE5ZPGkAodUlR/CIMpc5HtCTrOK9ZRVqtejrMdcDvDGqETLwrUhCoJwoYFHQ5aW7TTno5ef6Ym/KSY4pFWimIB92jdJ5GQTe1WmImWLJkwamNKOyS4AmDmAZokdZHldYCQyN/mIkWV72G2xXS5bEekh6F1aNINFYnOuJEn5vBNZXhXhQScE7Eik9n5FCG1P6qQpNY3AwMjQclYFevV10qpayZnbhSodza9AJyPt8irGMQmppHwTs8CyMqoxqbU08qsiZgRZhZVNkkpui0Vr1IeOmyhoawyBEIXLIuQcVFiSES3flpPt2eklR65WyaEOpESTLt4SWIqiMrR4QpWDjlu5I9rOVVEGmRiYmtwwMDLY0OookZq0pm8nPVrKO7Z6WWNvRUI4lLhOWkWSnJAIIpiBlfSvoyCElvs5JcwumPRxjj0zo16w2GEjllIZi+yzxj9hRcJZyy+EJnrMLSe1+CVbzrbd3BbLPSXpRAoZ6sU2MsocnzW2/Tm9RLJKX1W0iULzuTWtUK4bS96HVQJLPqf2AUbc3GdCyHXYdWtVJNuXc7BVcBltbTX1vhqL3LfKf/dq3IiwL+0jWb4P+vZ/OSQeDQsXQ5ZI7qcD4/7A7iLLlIb9EVFjuTGmIrWchpldiOxDLHnJ9+ijwdo9ZCYckpJsjftOdZXPqrHTxDQsTMMqsHw0LDwactlny/32VH437EPeVqEJjUel/T7JecnC2lT6/rg85Tk37INyGXK/fTEsPF+G1ieMDIw2tfqBXM9HhiajNCLJFizlMoslkLFVmXS1cU5Q6tzLP2dmvy8i3wz8VZEXN22Z2U8BPwUgcuaDgeM4juM4Hwp/MsJxHMdxnE80Zvb75fUrwM8Cfwb4QxH5NoDy+pWPLoeO4ziO8+nDByMcx3Ecx/nEIiKPRORJ/Rn414C/D/xl4MfKYT8G/NxHk0PHcRzH+XTyWk7TcBzHcRzHeUG+BfhZydN7BuC/N7P/VUT+T+Avici/B/w28G99hHn8lHA6yyWePcqp88Je5awgecXpPyQftiz9XFElt8fT+aMK3bTJ+/mkxPOTgnC7/tYJ4ZkXrbPTiden++5K6/70RfZgS9lQRCZUdu39p9MX+Hee/vP8xX/plwD47H/yGfR7/jxjeATA1R/8NYav/zbzf/N3Afibf/2S//l3v5kvvrvwq/r/AjDbDd928908/lqe2v+2/hFv83sceAbA4fgeACktXa5jmxpct1M6tinfdWpz/Rkgpqt7y3oXPhjhOI7jOM4nFjP7DeD7z+x/G/ihh8+R4ziO4zjwmgxGJIyD5dHz2RKTBZIpj4Yq4JPN2FQsg1BVVjiKMagxiJHK6M0gwqCwRNmcF002PyeTtk+SEpNyE2Vznc1424mRzzBmAylpGMbYHbPYem0ro2ezJWZZiOQRqkUi0YxYBGtzysdEIks5xkiYFUElEG1GJY9a1ZGrVI1yUq85kESbQK8K6sSk5SWgKEIq24mUr1rkmjPHvM9mrAj5ksUySF1kfE0ruR1BO6WXDSpKJMsJAcwSM0dmFmBqMRNWIehSYly3k2XJopXxvXxOfh07QWUCbuKap2Na6xxgScZc2g9kCeMxKdEgde3FTJqEtOajSu/q7lGMQarMUQhp215EaFLMIfUiwRzvmKqksUoLp1ujl0iOF10cjLiRO+Y7YWjHt1iU++x0sFfLv16qGEnAwjHlej4k4Sau4thdkCKWFZZ6WhRE4LrKG2WVfebyrde8KVmZExxT4lCkftccmGVubSPa3Nr/KadxqRfqxZ+1zOFUBloklzXdU1loPUYJmzad4xSboHKxLGRMpX0Lyijj5pxePNnT6yPvKtepCLYn371FZGp657H9vZnv8RLrpIQoXC+BubVVZRe6/i8YN1E4dP1ivQerCDaZYCbEIrlcloG0DKRY7u+opFmJh5HjMX8jcDPvuImBm5jzfxOV60W5jsJVGbx/thhXMXJTfz+wcEwDV0u+zvtL4NE8MoWl9Z/Xy8jzZeD5krffn+H5Ysxp7ROmEqZ6LwrQ36r590P/3Ujt32lxWpKSWOM0l37TWjvo2matB8vt+Nx7+YAEZ9qh4ziO4zjO64h/qnEcx3Ecx3Ecx3Ec50HxwQjHcRzHcRzHcRzHcR4UH4xwHMdxHMdxHMdxHOdB8cEIx3Ecx3Ecx3Ecx3EelNdCYAk0odqMoQaSYJfyWMohwqhZhneORJZZZjlg3jcFYzFpcrFo+T3FzicCxKREE2brRZLGMWX524EFNQUGxpI3RVgMVKrIDaKsWro5GUGExYy5pHNjC7McOcg1AKPtiGYcimDtmBIHixzkwCxFjlcEblpldRIINoKs4rwgY9btFbFkYGC0HbuyLUX2uGNoosJA2AgsIYvwVullFRtOm9Vr+mN2tivpazsnsiCsx+R6Sk2wF1lIspUSatXxdVK5UdfLGlWGuJobsy9P2kFLEc+NujaWINakpLlOhOr6pFwjJGnSy51lvWfsRJdLkfZZladqEVh2okwVQ1HmsuuYarlr/g0ziLbKQqt4skrvqrwy1WWASrx6AaFYli72gsoqxusxqWLTtBGd5vRik73W2C+y5HZR75kiP71OuX7DIkWammOySzkGyWhiz15uWLKWY1lliLbeo8+L3fUmJm5S4qYIK6/1mgM3TQwZbWZJh03+axk225Y2caqSz2Qzd9FLJs3SWYnl9pqJU41mKnV4eu6pnDLnV8s5Oa+rXPN2V53r6LTM6Va5z1HPOxVaart+kemSmEvfcyiXCiKMaa3HILCktT1fL/l+MIx9qcxjEp4MA+8dsnz2+dUlw7CQijg2LgOWhDiPXF/lpaeujjuul4HrZRVYzifSWsjS4GTrfbaYtfZ0E4Xny8B+3hFLn3wVB95fAs+WKrQ0bmIu55qm0muRVc7/fqn7BgS17QFZXiktr4qW3w9rP5hQRvbrvagz0VZpahPPlvqP6RohIDKgZZ8vJOc4n0Qe4s7+JPUeH7Ys/XnxzL5+/zk+ScujfhKpy3qeq+eX5a5lO1e59+kSsEI485nMNkeoTPwz+78AwH/+p/+A7/+hX2L8M/lz9dUP/ii73/k/+Np/9jf4L37xXwDgv/2nf4l3rv9DrHwGbinJVF7/Sr6KrcJsbOEr8nfWY1DG4cnm/JSW8pkj/30R9GKb6/p5VPetbMkOBL0gpkO59h1/iH8A/mSE4ziO4ziO4ziO4zgPig9GOI7jOI7jOI7jOI7zoPhghOM4juM4juM4juM4D8pr4YwQ1jnMkcSC5Vk4VueU56M0rOcEgaDrz4MaCsQyhz8aHETYlWOqM2Lozslzk41QfA9BDDVhV9IYNXsWqsMgWPYrTKLsykThXRCCGambIiQCMdV8ZP/AISUOKc/HOZKdET0JOr+FYRhJep9CIMjIQJ4PtLMLLuyShYWx7As2oCiD5Wq/tAtGBgaqg0FQyfmvKQcRhm5O9mwjyYxY6uNgkdkekbLxoMvvmreRAUXafPQ6F3tAmMvc6ERi6c45yDGn0fsFrBgqTqYk1dgGuXvm3lKdEQkOSZrDwEp+jt0c+N5xANkvoUKr01mNQWC27JeAtf3UefM7sn8klXnkKjCW9NvsMlk9FwCxOEhqTGaZWxyluEBEFDPafPG7HAYqQ3tPCCC3j60+hHM+gkRCZPVD9G6B1u4MEkeO5PljV0lgps3N3wfhYsixrG13LnGu924tc+zqsHoGbmJtc8Zia/uILESZ17xJyGXrKt9ILWZ5O9465hzZ4xBafJRA6v0EhOZlqUixmeS45ViZhM6RktNoPhfC5pzsdtl6KwLjmudyjHbnACwsuY42+Y+t3NlPsNbdev9lW8Fp3oHWN6zp5fZ4HbX1AWaKdPUUTVgSXJepie/NiesYmS1xUTrlixC4CANPxjwH8Y3rR6gmrORxnLO3Zj7ueHZ1CcCz48RVDNyUCriOwiHK5p6xMxWq3ZxFs+x1mZMSSiznpMxJWp+Q29+aTpC1Tx+73wf7YM0RU7uq1vdL9kH0Pgst16+5EYSR3SbWiywcu347ypx9JlKdEdn1Ur0m2uaE+vcIjuM4juO8/vgnGsdxHMdxHMdxHMdxHhQfjHAcx3Ecx3Ecx3Ec50F5LaZpOI7jOI7jOJ8kfFnE15/TpfzszL5z1O9CE9vvRU8Xx34ZPoq29CLXfJnlDu+Ky2mK0k1T3C4Tfn9O5Oz0xv79yn3HvWza9T25Jxa3z10Xvv/wfNhlPE+5r6+q+2M5rkyJlRFISP1T25ZSxu1SozG9y9+6+RkA/tm/meBvJJCb8u5/3S2x+TPl+OdgqcVLZQ+i7MfPArAPbzDKBZGZt6++WLKvYAnVoZwzbZauBxjDI6bwmFimhQYZURlIZanPvTxFJTDbTTvnCZ8lkRhKGX/z+hfuC+Kd+JMRjuM4juM4juM4juM8KK/NkxFVYHks4rpogXnJo2YK7OPApEWcp8I+CPNQxYw0edmxytAW4TrCMdb0Yb/10p0dcxSxNoITTgb4RpRBlFE72V8VrXWCPpVOWljkadGMuQn6IgtLkxcmScROgtnyY4p2IjNBCZJFcEORVZ6jjoaNDIwoY0lDJb+zD9pJIYVBYLEq6cxjcUspkCZBTVr95LgZC7HtU6RILLcE0ZZOILCwjvQZiUWWIhQssSoxafJDE8YuxnPKPy/1eBUkZQldFUvOKQtPe4HiYjnPVUan5H31mBqDXanwfRAuQpYy3pT2U5oih1RHKrcjzKPm+ApwXcSMV4vx7nJkJ7nhDSIsZtyUUchrveJoVyx2wE5Gd81qXBKQEDkVD6ZWz0bELLVzquSwSvKiLahFosykeh0Dk7TKLa2XkpZ9pXiHMoqKwRwTh1SkhSmQ0I0csNbRMeW0blLiYJFY0r6UkWiBZMYh1fvBOBKZJcdlYckSS7bSxyz3XMWMpzE7RUQ3kssc10iqwsczA/iJ2MSW7RwSsbW629/rVHVrrY/62uJZRKWn96sQNnsC6z1dj08nVxNCE1cCd/YB9bxwJo0kRrQa+0SyxNWyCnWnOLBgPNXc14gIowg3pb7eT0eeyw3Xetb/VF4AACAASURBVMXOsrDx8XzJZ4+PuYo5bjEpZkIq/bGZoJoIYUGKMDghxJT/gyyLPabchuo9dEjGIUXiSV3XPmGx/N8xKbXdXi8Dzxfh/Tkf9O6ytHuuxmROIffjx9JXKowi7f6OBnMyrmK+7jM7cJADx/SImyglb0WU2YW3r7Mqgg0MxJN2mGxbJ+3etSXfvxbatxWO4ziO4zivK/5khOM4juM4juM4juM4D4oPRjiO4ziO4ziO4ziO86D4YITjOI7jOI7jOI7jOA/KKxuMEJF/XET+XvffeyLyH4jIZ0Tkr4rIl8rrW68qD47jOI7jOI7jOI7jfPx4ZQJLM/sHwJ8CEJEA/B7ws8BPAD9vZj8pIj9Rtv+j+1MTlCoXVI4ysxB5zrq8yC6NzRz3mImdBB4PWQp2TMp1DFkeSRWfCXNahYNmMKoQO0lklTZKeTUxkq3HHBPcRGNuYkBjtsghSTv3Km5HfKokscreouVzZhKHIuS71muOct2WV4kszJaIRUyXLC+Pc05OFxjbz4sszByJktNZWFBTYhEB7mzEGJupUxFGyfLKtlCN5WWaVrFkvn6VEs5FPngqwYvd9uFENNiw9b0kxsyRpeTtIDdc27sbgSUCz+UxX5uHEocdl4MQ+0M66WDnTWRpdZY4pMSNZfHcFQcSiUBgKrEbEFJXBkG4lIHLImack1DtjavA0rhJxlzq9VDaRBXjjSgziR2Bm1Lmmchzfc6b6SkAexsxrMXkINcs6UCyuRPYZWFli4tlyWffEpaYssyxCPJElJQWUhVN1vM7M2uwgWhzSzfKjJgiRW6a5MBoUzm8iGNtIElikRyEep8ky3GM0RAGjFX2Oqfcdq5Tjf+Razm0vCfbc1iGojKtIsN8bxxkvd/z/ljOKULOTmLYCzxr3O7aVyWdRkIkrDGwVESYvRQzoRK6BadqPdCOWZeSiptj+tdo6z1hRWCaAGTdL4R2X4kkoi3ULjuyMMuByHJreSZk7QMSqQkta1pD1+1X8WbtSxZZsiC4ykJlYbCB5/KMiX0+1pRFFg6l3R7kyCPbd+32wHN9xsGekUrbOMjnOMTHhCKnnIaZ3e7IMOTrhGEhaM7ftMuyzIthJqgRS7vK0kh4vlgTWM4pccVxI8tNZhR3MYNsF0rL6QhzEm6KfPLKsnCzl5AChDSgSVucBGWWVeR54IahtJ1rfY6ReCM+4Srm++QQQ/49U2W5TU28jXnuPde2Em29V80SyWZSuinb+V4xSaTSh73MonGO8/HCl/V8eT7Mcqi1l3gV8T6X5otcJ97x80PzQfH844jdy5z7YnE5n+IHx/GDcvKqSmkvcMyL09fZi9TPud+SL5uTFz3eaJ/97LQ+aj4UKZ/73th/L//pd/wgN0Xu/Wvvjfz9Z8/4df1VAL56/avE9BxhxKifC+ZNfpI9B4Orw/sAXJ3NV15ydInv3ZP3xPM7y3SeP7y158Pdyw81TeOHgF83s98CfgT46bL/p4E/90B5cBzHcRzHcRzHcRznY8BDDUb8KPAz5edvMbMvA5TXbz53goj8uIj8soj88sLNuUMcx3Ecx3Ecx3Ecx3kNeeWDESKyA/5N4H98mfPM7KfM7AfM7AeG8niw4ziO4ziO4ziO4zivPw/xZMS/DvwdM6tTS/5QRL4NoLx+5QHy4DiO4ziO4ziO4zjOx4RXJrDs+AusUzQA/jLwY8BPltef+6AEFHgsWQo22UgkIQixE2UkrInwnhkkS9zMF/k923EThYsgjFole3BM1iSHsxmHKBxTfv+YhCkpaGIo0jURA9uKUAwj2VbuETvB42KJURQVae/1r4slsoJwK4DsORXUqQiDCYGBUGSBQRbEtsclEkl6uWQiyiqyO8hh4yUJ5fzRZJOb2JVvLmWbi5jlmpmZhSQnMejEekYCY3PMzLHkIU/BWWTBiMxF0BZt5pCedWXOcpcrebaK3xa4ioHYyevGzmC5WFYgpq6OjkQWIs/k+eb6F3aJlWNCSV876Y3K2OSj9VWA0pwQKWLR8t4hRQzjeUl/sMBzfc5ouybK62V4Femv2dV7FUlCltr1beJ2+xg359wSHJ6kd+79aDNBxq1AtORJWny0yRHztmzEpUCT99VypbJvlVNu281MZCn6ysoiWfxX20wq8r4q9VzLEZofSFCCjCSrAsit4FIITSBUX/PxsbU1IQs81/IGEpHA2ISD7bhyTOjkkQ3bCjVVwu06QxECgxU5K4mBgaWL9chujXfxN4mEtk/Zvp5SrzkU8Wj9uc/LYOHs+UlSkzkGBkbbtftjZyNj96tETXNFK8QiXLpMj5kCPCnCyovxyLSbCUOOY9CEhsTAwliO2YVIEGvSy1HWe++0z93EUmQjss3HC2ZrG4zW9cEkDnKzaV9GlqIuHMr5cVNvgTG/Z/l3TLSZUSZGtMlaKzXPIwOBofW/gQFFs1iYtc1VoSqUdmMB1V3OR+rTPdPWHMdxHMdxXiNe6ZMRInIJ/DDwP3W7fxL4YRH5UnnvJ19lHhzHcRzHcRzHcRzH+XjxSp+MMLMr4LMn+94mr67hOI7jOI7jOM69C/WefnfYPxn4KhdsfJ25a9nOPs79ctyn7xnnl5A8PeZ0+6Pm3HKXp/m/a2nMD7N07KtEup8ChiFIe3pWJIClzZOvt8uttMc1ofz8KstZn54OqD5qTzZejp/jkX6Wz6fv4qlkF+IPf4tytRh/+6v56chfmP86z46/R0z56W2zYynRdjnPF82HyiUAIVyS0rE97awykGz7BHtdOrzFycpy5+VJarO4eXr7tC4ydz/lfx8PtZqG4ziO4ziO4ziO4zgO8DDOiG8cER6HMpfarI1v9eMvx5TQMic4zwE+tPnoWtwCoyqPQx5/2QdhTutojCCo0Ob7BoFBE6MYQfOVJk3MwKDWjsnn5ZNmMxKGWGr7KnWO81znyld3BEYk5vPKiJNanqte5wQPaWAUbb4LQ4kWGG1gKPOLIwMiys7yCNxYXo1dm3eeJKGmDKXaA8NmlKuPrzWnhaEia/4tMXdz+g8yM3NkkWWd717mo/c+gSTW5mQrykFuSCRuyF6IaHO53qHkO5FsbvP5KXOqE70DI48TRqsjfbmOl5LXoea/q6NoRkBJlkcLL+yCkcBIjnHOnxQfRKkP4M1d4KI0jn2AsRRtKK+HKKj0Y3s7ohljWveFpAwEljKCO1v2oFxKrqtJlATcpOIwsLE5C6TOKRcFtPkSRPTEnXCHL6BzH9Tp9iLbY0/9ED3JYms/m3RRBst5GwjZ21GuM0q2DwSR5tYYEVSV0apvIDDb1Dkk1lIstY3ZDAIju5pRouRag9x2VLT5Ic6R3+dk9Dzvr3HJ8/W1xcUsNU/ErfRae6zphLK/3Guk9nMsafcuilMvg5DdD6f77/JA5O0BLN/H585J2ZZy9v1Q7tVad9XnEorJoGETAWWMI0/JfoRRAjtVhuZQgVGEufQ5czJu0iVX8Wlr62/pBU9GYxfy9hAiISxo2Q7DAmoESQzFIzFqZBRjH3KUowUWy/daDLWMMMVx4x4Jp8IIQDtfTU7T2Jc0LtKOg+1bv1j7l8jSYjkwEGzgUXoEcOvbgOe6R5NyGQam+vsiRC5DYKc5xpMEpu46gmLVDSLV/bP1QCSbUR2wlGOiyi1XysfpOyzHcRzHcZyXwZ+McBzHcRzHcRzHcRznQfHBCMdxHMdxHMdxHMdxHhQfjHAcx3Ecx3Ecx3Ec50HxwQjHcRzHcRzHcRzHcR6U10JgqcC+GPBSJ1wMnafs+QKkLAQ8WOTAsQkTrxk52EKKxlXMkrXHYeCQEqOu4zF7CyhVTlnkl2Kr5FIM6bdP8jkX4Zlhq3hOZCOzNDs52SARCEAssjct/2JdggUliDRpIgiLKRdxx6GIGKsMbV+2pyKTOzAQWdq1FG1Cu8d2wSSBUDIziCAiXAZlTjmjI9sFcDQJgylLkagtNha94tBkeFgW4jU5HomJkbFc1zAWWUgkokyljIFkkShzS0MkNLlgLaOi7CxL3iYJ7FUJRYY4irBTQarfTYRgtR7LMSmXcUpVJghTaQO9+C6IMEhLhseDcFnullGrhBR2tV0anYIUYsoyyqkILJMZlzaQ4JYMdCrCxJ1qEWyuMsQqSlxjEDASvaOvSi0rRkQ7EZ6Ibix3WWYZVhGerPJKuWd8Uk2L3C+3p8TA2ElQA8qINhHovotrE1hKuWAhldjFEpNjWvWkc8mfmWFmRFZBamAVWAYZmdP1nfkGSGXpp1X8GTAiybb9SL5euW5uoV1e8/lJYqsXIyEoyWJJd5VQ9qLVnIdyf8tWvtvLKes5d75WuWYRuc5yuGUwtFvXX9p7Qq3Dte4HC+3Y2nc1mS5KQLlg5FEo950K+y5o+yAEgTkVkW+CfVLGZT3m6RjYB2MscseYlJSUFEsfkQJKxEwRqXVkqFhr63lbNm0/t4vURJkAxzRwE3MMbiLMJsxJQWsstyhF5FnSVct1OjAwlWMmm5gYeVKW6KrcpBzbo80YCYWWPyXXde23RxHGNJz84rgtLYWtTNYsrW3SUlmCa27SX/9GwXEcx3Gc15XXYjDCcRzHcRzn40H3bcKDXe/jvG5KjUcdGjtd86z7UqGsKlTXrP/G1qg3tqN7fVq3V9W5ncfTtPpz70v7VXHfNW6v6vQwyMlW6OrsXH2dluEbabv9fXZXfd517XPXPU3jdF2+0zTuOu8c/bBw4vww8Qe17xdpv/edd3ofnsvLXfdmn7dz9/OH5b409EwfcDf1uPxa0rN6fn+du9rc6cpzdftl2ud9fYIgBD5z+ScB+Kx8ge/TL/Dnv/M5AN//hd/iO7/v/2P35v9DeHoFwC/9pT/Lj37xy3z16ldyDu3qjrRfLo8ql4gMfO/FvwLkFRbf03f48uGLAMR0QGVgDE8AUBlJNrOk6/ZlZrK53O+57zFbEBna+0t8TtALVAe0rOx4ffydl8jnin+p4jiO4ziO4ziO4zjOg+KDEY7jOI7jOI7jOI7jPCg+GOE4juM4juM4juM4zoPyWjgjBBiKAS82IeEqD8wvypMid5vTwONl4DrleS4XGhAR5pTarJublLiyGYlFbIhyGXQjyIRVWnkXKjRhn1qWvY1FrAgwqmzEiNG2aVV532zGocgODzYSbGxTkwIDe9UmjRMgmjCnwIVVAWQ+96KIK6ciFpxsbPOsFiIDgV2R7z0dRvYqBK1xzpLMUXP6ffxrruekJIOlCC6v4sBsRjTbiuVYRW4RY68BK2VPwBt2QbTEgTdL3hKRyLVmEeG1XnFt725EboGRkR2XRSv3ZAhcBN20iVGEVOJUHXtBaALFucQ42iqGDNKJRes+XWeGBYHLAXZFXFkFlnMSVNa5evtAE6DWuqpSPwOiQUywlFOuY+ImJi5CzssU8vFVrjnZnkEmBt0jRVaXbIZEm8MFWWonso4rqoxoN69LRTFZjzk9ftCJIBODTBuBZZCxbQfRJrDsxYyJxFCOGUXZa2AqwX4yKIvl2NdUg+Z49jNB8z2Q9xyTZBmo0e6HKSlXSQlW8sKQ27vUPEQGnTCLTd4oaBGgrnGKJ9NOa/lCiVMfk5rGqUA0CU2cmfNSY7xKR4WwGeU1OZWQajuuola1tat8so9zPr6XHSpCItn2mJ5w0r03qW6TWJ4ndBJSRRgl92H7UPu0te8F2Bf3YxU1HmIWxkZb8zNpVuzW+29JgeNxK4PUELGkbf/1PHIVA8dU+/6+v8/MZixEDlV8C1zbwLHcQ7MpcxKiSRPdQm6DY5XaSu5Hr+1QyjwyEtAiZAW41IGLELgcVmFtNOP9Iuk8xD0HZnaqXIa5xGVhpwM7rXFSpjSitRwIC4kgQ6urLEANpBK7vD1gsso3hYR17dZxHMdxHOd1xZ+McBzHcRzHcRzHcRznQfHBCMdxHMdxHMdxHMdxHpTXYpqG4ziO4zjOx4OHXmbz47ysJ6z565efPP+zdVPLXrxUp0sX2pn37jrnlHPL+Z0uo2hnjvm0Yidbyzd0/qs993RJx9Pt0/RedLnU+5YWFTZL1yKsE5Lvyv99y46+7JKecuac02mYL7I0513L8vbv3U1dolOoU5Ot7c/berK9LtN5uu9ubpfDbtVhjUno8hW79yovv1SuyB6VqdtWLsZv4nPhewD4i5//dv70t/8O13Oeavqrb38Tv/sc/qvfyOX7jd888P7/PnJclGT7ksovYHaA0i/2S2meycFJOe8m2Q3CyJfTlwC4mr9KTNfr2bYQwiXH5d2SWl0qNZ2JaNlj5d6vU5otEdOzk+VZZz4M/mSE4ziO4ziO4ziO4zgPymvyZMR21K/KKy9L7kPZrsJClSyxPKZ8wD5A9o4FnpWBnavF2C/KXMyFQdbze2JS0DJilJRjDFzFImGzfO0qq0w2chECg0gTGI5F2Ne+N0jSxh0hj/NFM64WI5W8jDYwsSfa0LbHTqioUmWTyhDz6F+0lPeVKh0lMIowmhLrOK0FRlGmkt+no7JTNnEbFUYxlk4WF8Sa4HG2PIZZpXL7JTCbkWwVy8USriqwnNMqdOzrMJoxp6kckyWYz+IlAO/ziPd1z408z2myEBiY0p59EQJeBOXRQMsrlPHQsjkVsd4UrO2bU5YjVlFptCqj2+YtSN5f63BUa+LKLMTcjkqGEqdarxd11LfkbTFYUo7foQ07ZhloFf+NIiQxpjLqONqOUSYW1pHYQSeMROoHiKX/MTQRo0ovc9Qmo0zlm41eVqkSssyxCBmDjLcki6ckSQTrxYjCpGvbfzTmMvcMmu/F2laSrXJPgBClSS0l1rwpi4VWH8kMtYt2E0WZiTqTbCHaOiqblYnnR5iNSLIs5mz7itiz/+YudbGtMksjdbGMRTgY60UJ5PZaqXmq51Th7im9tDLKfPJeINhwSzx5Kr3sJZbx5BssKxLMRZY1HQOT9bqLKBgEav+luR9R4dGwimHHLvt7tVviX4BZpfUbIrnt35T+6rgMLDGgy/orSKOSknJ9k78xeDZPzElIVq9rTZ5Zr78rfWDs6mxEmzRYKP2l2HrPmjDI2ic9SoGQhF2RXqoIk2juX0s6+yA8GtZ2e0xZNtskmEWqug/Crvy+GDWxC5F9sJJXYUSJVIGlskMZbGAs93ggi4urfDaQiMztnhaUlMr9W4W0tyLvOI7jOI7zeuBPRjiO4ziO4ziO4ziO86D4YITjOI7jOI7jOI7jOA+KD0Y4juM4juM4juM4jvOgvCbOCOMmrubVIMKucygEgf1o7MucfpE8x1/LbNrHY+QyRKIJ7865yM/mwLtz4HmZVr2kPJ+9egG0XXmd929kV8AgdQ4wXA7CZZlL/SQpF2WK/aBr3oR1TrydTMFPluce5/TzmzfLyEW6YCmT5i/YMXXzpI08Z3uxPAcZYCkz/MfqGxBp86aHEqkkef8+5GP2YXVa1LyOatnNWyZ7V39CJRQ/RI1+CjCYEDtnBIGNC+EY4WLYegLyz8JcpnrPKc8v3y35pGFRJEmriIPcoKYMFhh0zdDpfGnr9iWDSbMvYix1piostlp7NcHC6imo1LnmQGtHLQalDZTp9eViOXbhVhnzEdGyL2Q2Wr0slt0bbX671Pntpd5SaM6G6huQMu9fOteByrCZR64yZOdDmXeeq2QklXn1tVw17SATg0yMsieULiHYSJKEWncd9JaXQE/GMwW5NV9/+37e12IqUtwNNbb5dWGNU26XSkw1lgNHYChOlYkLjlyhElDJ+8zSagcmex6U1OpYRVEZCV2Mqi+iOTfO+DJO9ylhm8bGqq2bV5Vw65jKaayl+SlyH6CmLf7b62/rYuMBoXoztnE4NwZd0xlOOyjWPqC5TbQ6eDK5r7PWxwmS61hW97WWe3AfcnnG8tr6VlOs9jnFubALkUmNo1ZZiDBK7rdqn3mIyi4GjsWPYeVfOu0YyPct5HwEsXafBRH2ukYy/35RprC2wYsAl0N2ReQybvsL7WIYSv6lOGRU1nRH0eYCqr7yyaZWrwe9ZLEDJqmUJ5G6NsnmmqGGxXEcx3Ec57XkNRmMcBzHcRzHcV4Pzi2z+I2kdd/2Q6X5adfFnsZIT5b1e9FU+i+UbLNd9/XH1WP6/XeflzZ7Xj23l6y8T/zd6L5QohMw9/uFEbtzqcReg/8CeWzLMtY/++46L5TrxvvTtrSmZQuIbmpDapmk/1Jm/TJEWh668p5ZOjLX6csuw7me8423gLZ0AGYz0Q6bd9+P7/A+vwHAv/+lgHxp5NH07QD8CXnKe/oVUvmCYrEDMR1zvuoym5LTlfqlluWYbNqThE0byXXTifvLuUN4A4AxPCJI/gLynetfLcfkNEQvcml0z6AXDMObpZTKoHue6reykMs4FLH2lX0dgEt5CyNytJz3yMwkjznaFTvJiw98+epvvVR0Kz5Nw3Ecx3Ecx3Ecx3GcB8UHIxzHcRzHcRzHcRzHeVB8MMJxHMdxHMdxHMdxnAfltXBGGLAUudlixqRZfLZK74ydGhdDnlMzaRalVWHZZ6cbLscjKsazY54D8/6845155OuHHILni7CYsCuytFEti840dWIzQ8QYyjH7YCRb5+3EKkxUGKskUKp0L++YE5hlWWHdHyS/Hsq+SQKzjYQikxtF2YVVIAcQNcsf67wiRQiEJrAMRWAZRDqho7EPyr4ErsoraxwVOztrcpUx5p/NtvOwTudkCVvhXS+z7N+PnbiwBnks06J2qkxxbJLCG4nMMnMt1zxLuQ53S85xFcmNq3GyxBYSQjLbSN76/C62yit7IZ3Jup1ECHfMPOuzn8uVjwvbrOT3y5S5qLWMspEBhiIYHZoAUhhs2AgrVUZEDk1UaFZlebp5TZY6UaWWbS1xuT3/Lh8T2/kTA0udv0cWLC623BItRpYm31sssdgqMpxTjm3fpk6FllmvuN2pAmK9+A8GWeWsyUKeM1r7BFnYy2NmOxDL/MoocytTLd86Z3Etc04/z7dLxDzPrsw1TEQCq5wSqgByPSfavEmrF0rWY3MJz0gjSxyTJAYbbskpT0knIspTQWZkadLK9fj1nCq4PL1OLyVdJJJsnQGcY7z2F7nsuX8s4W/tN3a3SBa2dtewnJPaD4oYqqnJKlMSRASzbZxGTex0vcus9CX1Xs/3jzJ05wXRVT7byVJrX6xi7IKxL9N6byKoCVYlniIMkvvQXmQcLYuOW/lsO1NayOdVKWdQYxdik+eOKqgI2p00ijJaIFnu00abMEmt3RmJJPMmti2mf2xzYh3HcRzHcT4a/MkIx3Ecx3Ecx3Ecx3EeFB+McBzHcRzHcRzHcRznQXktpmk4juM4juM4rwunE4jq9gctoXm6HKhPRPr4cFoX8UPVzl0t477jzv384VrG7eVJ717Csl+Osh5Tz28ToM/k7wVy9gKFNo4fnM7L0k2/vfOQF71un9aLVOKL8oHnCNulTV9lH7Gm/XT/PXw+/BMAjLbjz37ms3z342t+8Dt+E4CvvPsW//dXv4lf/MPcRn5x/l843LxNsqtbaZ0mb1aXcM1trW9DdmZq9SYJy/U1L3+0ed0eU9ppeh/IUVviO5tjBOHr/MqtZWft3qVVb/cJHwZ/MsJxHMdxHMdxHMdxnAfltXgyQkXYaxWfCZeD8HiAN3dVWJm4GBKXIY/IDJoYO/Hk492BJ/sbpmHmyXIDwJPDnvHqUZONiQRuYpZS1jT2IbILsQnQgmZh5TFm89kxKaBNdLgk2AcY1Ji0igWz1LBeZzZhToJWsWUSDkkAacdECxAnljKS9SQMPBmMoUoeBZJl4eZlylWoxdC411VgmeVtPcI+CBel1geBQbJwc401JQ/5tcor5zIofEyriDNvrz/3aQTZCiF7CWaVwUW7fW5LgyrlzJkdbSKRCAwkqhTUcixPzqvyyCzotE0cTsfstORzI/IUGMXa4OCkMIXEZciZ3YXEKLaRM84mDGIMpd6tE/UBLElJJtxEZZc2WstNfo+J0h5gWkYm2zPrYyJ5BHrWKk48dGUYWdKh/KwEmVAJDJKleIERlbCKDm0m2YwWCeOgE3t5TLBVGLq3yyJEzOccOTbJYj1mtJGRgUvZ5XM0sFNpwsFRtxLK/GqtXmqclk4EGIq8U2U9N4v/YJeK0DUKsxlDiZMkIWmW/iUpMk0OJIsEXQWUix0YyrcYgjLIhBKajPIcfesyEskio0wEG1u8hdBklFr+HeXY9kXJ8WrnlH+9hDS361UkmSw1AWauw4HRdm1fPXZzTrlXTrd7+usCDBbKvlWEO6KtHoLk+pxU2GvtG7Oot+Zup1bElPmcY1rvC+nvKTV2Wu+hhXFYGIb1mxUNCYhMuzzKvw8zFyGyWM1b/v9oshFUChAIXaxkK+Wt/U4nG+6xIqNMxciZD8ti3Pq9X7AsDLbuHJW+XZd+V2Fffg/tw8yNDk2svA/KpJr79xKtQYTZ1j5tZEdk3shJ5aStAJu24d8oOI7jOI7zuuKfYxzHcRzHcRzHcRzHeVB8MMJxHMdxHMdxHMdxnAfFByMcx3Ecx3Ecx3Ecx3lQfDDCcRzHcRzHcRzHcZwH5TURWMLjsQrVsiTycjD2oQosszCyisOSCTEpViR5cwocl4GgiXSPxCyfu+4751ZUsSafhCJiLAcuJtxEY4+gVQDXpZ3zIixpFazNJkTLYrT+eqlbLkUli+C0y7qRlw+yPnH6JY+ybDOxnlcXJ2rCTYNoQrD13CqeXE4ElvWcY8o/rwJLY05bmWMQYRCK1K6P3RqzHAs4lo0qmbsu24eUmFmaqK1K+YxELBrKQ0okYCoJB8sJ1bzGUr7enlnrK7GKOI0sH+0FmyDUajYzgghzFTOatLYVipAvxlWgl8uzChpzHLO09LRNhZN67eMTiSRJpCJOrNxOZUt+P9x7TI9m5V+L8X3XUNsKEKteL/+cRYC13o8pSyyT0Q17ChYNKRVulu+Bvs6CwCF2cSjtbS4HpXKdpYpMiVkuKds892Vo4scSxyocMKZCyAAAIABJREFUlJcYj+3roF4rCyRr6dkKJTfH6Jq/Uq7QnSMfUKen5enzUUWZp+nnXGXJZUVYRZv1VTZ1ePeye/WeUclSSCsCUcOIBodymUPM9/Gh60yDCMmEUXMMRQzV9f28nRBNjGOWWu7C7SWiFGMXErtyv+1UuAyBWBpLMkNlFVxK1/fVe7KWsEl6qV1EEaIiiOQ2VrvXQzkvdOmKSUtLkU2ffRdZlFv7BGMxI5L7OoDIQmIrL422nG3LVWbpOK8XL7MM36d5Wc9+CcnTfvlF49Kf1y9P2S+z+mmL8Wl57+tH0z3HnNbPpy2OHzUfbgnJ+1l/o6vseTx9gX/3jX8VgP/43/hrvPX9v47N/zAf8STy2//bP8Vv/f6381/+3bzc53/33s9xOP7BPUth9vfjeg+KjN3yna96qdI+D6efmesP8dzeV4o/GeE4juM4zv/P3tvG2pKlhXnP+65Vtfe5t29PzwwzzAhw+DABHEcDCBEMimODRSyHGJRgFMlJCBAhy1FiCSUB4l/OH9uKZTvOh5WRMUyUOIYgoUGOY4EIX0rCgIkNCl8BhoEZZhhgpmf69r337F211psf66Oq9tnn9r1N39t9ut9ndPvsqlq1an3VOmdq1/us1z0iEkTkn4nIP6rbnyUi7xORXxWR7xWpSwM5juM4jvNU8IcRjuM4juO8EfhLwC+ttv868LfM7HOB54FveVVK5TiO4zhvUPxhhOM4juM4r2tE5NOBfwP4e3VbgK8Evr8meQ/wda9O6RzHcRznjckTdUaIyHOUX/x/lBJ48s3ArwDfC3wm8AHgG8zs+YflE4A3DSVuJSoMatwKmduxxLVEMUbNhJXL4ZAVauz6nJW5eiNS1r7vMgUuU0lzmYWUt36FKMagGWXrBxhXP4Nojw7qDgY1SOU6Y8jd+QAl3jqstgeKz2DKMGpLs41BFoRBYdQlxmjIJfa4xd5rjV8emz+huggE2dZJy7+W5jrkIZ9Vtu10mqbR8reqbGjbLZS8xHEv6Ut522dBTdnZrh/PZHa2Y6jDdqfKPmiv8y5s47pLfLb1n+XaQtClECrSY8fXJFvXaZtGxGq+1j0lrR0G3cZgNUeJiGFWXRq1LIMUp8Iyvsr4aXmtHQ5BhtqWuX8u2/X6sqQ99SBIMzvUNIGhnrN4JaJFArFfMxARMtHClbzavqGmbzHwQeQk7dU+F4p7oMXiNx/EGpUyWSxuEasuiubhMDLW3SFZrHsRWqxetkePJ8y9Da96Nk6dC7D2RJT4/QzIyleRrZROTrwdvWxS3BsPc3+U667cDqaE1XQtzU1hKw+EbX0Q67yuQxBGIrIa7VGWPm3+haBLH2Yr93TzykQTUv0HS58e89JyIV29h+TE8ZGzEjQTQvEn7IaJMSRu1XwHMYasHLJwDKVOxyg8mIVjm9cxdrqaE9QY6r0a633Xfl+MungnshX3Ranz4slpQzrK4itqacp83X5/KFPOjAqxzgFBjSjL76Xmi2i9kShuoJnELHVsnPgiynmxjx0RRRlrmXb1HOcR+dvAfw7cqdtvBT5hZnPd/hDwaedOFJFvBb71iZfQcRzHcd5gPOk3I/5r4J+Y2ecD76K8HvkdwI/U1yJ/pG47juM4juO84ojI1wC/a2Y/u959JulZW5eZvdvMvsTMvuSJFNBxHMdx3qA8sTcjRORZ4I8D/wGAmR2Bo4h8LfAnarL3AD8GfPuTKofjOI7jOG9ovgL4syLyZ4A98CzlTYnnRCTWtyM+Hfjwq1hGx3Ecx3nD8STDND4b+D3gu0XkXcDPUuRRn2pmHwEws4+IyNvPnbx+LfKO3jmXxHEcx3Ec56GY2XcC3wkgIn8C+E/N7M+LyP8KfD3wD4FvBN77qhXydclDYkHP8jSWtLspSzHaNZ9fbh7nQhdfTr6nfbpeMvRR8nycMdFe3r4uGG19beXxl3t8JcfBeny9kvmdcrosa+Bq+zz8pXdBelgiNSD0XB4tfLOECZ5L8zDW5XwY5/J9qTb8g7exEFG9DcAX7/4s3/DOC77mC34BgM/56vcx/ekvB+D5v/KTAPw7/8u/yk98z++Q8os1hwT8zLW5LyhSQ4CFAZFItgPU6EAjUb6rfyVYB5cHkOX/4r/l4gt4Rt/Kh+6XMud8bzUGWEJ15czYsRYGfW5Z3NP0Ly9w9EmGaUTgi4G/a2ZfBNzjMUIy1q9FXujFkyqj4ziO4zhvTL4d+DYR+TWKQ+K7XuXyOI7jOM4biif5ZsSHgA+Z2fvq9vdTHkZ8VETeWd+KeCfwuy+VkazEYUGMqEVKOEgTjtlGoDabcJkCVrcPKRLnTJBMqpK3YwrcmyP35pLx/bmK2mqeY0jsQmIf5i6uFJZjUORoChxyuc69qZRVRcjapGXCEKw/9QkCotYFkACkIjJs0jg5eZJYhJZL2XSVYi2QjCIreaN0aWTbp1WY2EWZWC1vLUYuckurn6HIBoNYFw4eahljF1hKl7y1NEGrGG/1qGvQ8q+1QRA4Zgi51bnVo4rzEhxyWGpa894z8oyWYXtnUJ6JckXI2cZFVNiH8nkfSoWOWcgmzS9KyDDlIpYctAkSl3q0su1C5lbN406cuYgzgyb2sTzdvDeNZBMGXZ7MJ9MusAxZSVk5aCbXMRjVGG0pYxBjEOXeUM7ZT5HBRnYsD+NUlEzq0sLEhEro20YRXIookV3NdyCyQ6tQMUuqIryyHdkxMBJtmQ4GixjGrskubRl1sV5rV8WHe9XaxkIQ4XbN5lYwosKcFxFg2HYn2cq4bUQp54wq3KtaOa0S1kHa/V3GTUqx5mEkbnFkebosEqricu77EhNJptqnSmAgyLAIPWu/5JVYcbSRueYRZMBI7Gzpj3YsbuSS5SZq4shcj7XtIgFdZKGzzL3t15LK3CSVFEHtcDJdK8JEINQ0E4Eshtp2/sgrsa+abKScihBWiktBGER6Ww8q7INwEZZx2u6T2PvUUKQfTyYcszBl7dLRXSgC3na/7HcHxv2hl8uyIpqJMZFTHZeauBWnnibU/Ys+dKGJfAcRLoJwqzbVRczsQ2YMiVGbBLLUYRmLRY7aWimZkatsdqyJLmIZzxexpLpMTdpZzomzYFLmvNtDKfN+OHJvGq/93iBjTJaZmLu0MksmWyKvhJUiod8wQuhp+/18pTWch2FmP0YJD8XM3g986atZHsdxHMd5I/PE3owws98BPigin1d3fRXwi8APUl6HBH8t0nEcx3Ecx3Ecx3HecDzRpT2B/xj4n0VkBN4PfBPlAcj3ici3AL8F/LknXAbHcRzHcRzHcRzHcV5DPNGHEWb2z4FzS2F91ZO8ruM4juM4juM4juM4r12epMDScRzHcRzHcRzHcRznCk86TOMVI+pK8qfln8p2mRFp2yuZJVBFY8qDeSDl8vzl7jRyb1ZenEu6B6lIMtOJ/G2NShE+7qoIbaxiy8vqLLyfiqhyUKEpGQeFEelWRMUYdFVWIJsy2CJi1JVYbXv9pZ4qQrar8rImVCtts0gs2/lhJWqUvq+K50SqjK58bqUIVRAKEOq5UxVPqhSZYF4VVaVJH+nXaWJCaGWAIcOQl/Ze52EIFyksMj4bAbglkduxZHw7FlGd1nZqMs5W31GNneYqzKxySgHEmFb93BZIqt7I3qZh1UdFeLeWm85ELVLUkrYscbMek8kWGaadjMnSTkYUYactj3L1fSj122tgl0YOEru0Tqq0TuryO01it9RFN3LKfi0WyaVSRJd9WwKatW83wkqV2sWiSNcdBlEUYVcH5k6FMSyy2bFKCy9XQtYo23bNsJG5Dqvj0+qAZCE1YaKV8RhqG0QLtVSLmHHdHtT6luulXrdHZRFRXlUFrqWUrySZjK2ueLU/S43lpEyZTLulooW+bzkv1DSljYv8M5PbfMVyX5f0V6WjZkJimcNUyvzcxn4y5SIIU5Y+T4wq7NSITQYshmUl1/k4J0WrIDZVqXAy5ZAic0tDncuzMNfCTBkm286Tm/a45tBpb62TlfnAECniToBnB+N2zOz67yHlmIsQt9VPUHbBGHWu7VLEv63100lZetuLbftIAmpLfwcZMCky2qwzlh93+TrHcRzHcZzXJjfmYYTjOI7jOI5zU7j+QeHTx6757Dwep233uA9HH6ftXyrv9fHHWVfo9EvH5cu388dh+wg7n9nf9rWvt/6g2Evk1dd/4mr5z7XFUs7yleM6zfpzu25L97CyPYxzxx/lvJdqu+vyvS6NIjKALSurPbP/LP7yO7+Sv/hv/yAA+3/zp3jhH2R+9P/+VwD4u3/1C/nh/+LD/Hb6RQ7pLgDZ3out8ni0spUv9MxSLWWqRT1t71cKW31KYFZW4wLuzx/jRfso2R7U41bLoattwCaujumHlfX0Hn159fEwDcdxHMdxHMdxHMdxnir+MMJxHMdxHMdxHMdxnKeKP4xwHMdxHMdxHMdxHOepciOcEQLcqnKzQY19SETN3I4lfsesaNxuxwmAYwocUiA36WIT4uXQhYLHFJhMulQsZch6XngmG0GidXFb0Iys5I7HbAQpcsexySgpgkVZCeH2Ifc8zAQzI1mRGZbyljo3aWATVa4FaE0+uX6aJCKr41LFjUUW2fId1BirhK1IGWFoMrvaVlG27RDUSFXU1sSPTUx3SMohU0Vt2/beaSuXbcSZyWCvxiFLF8CV/VLln6AiHFJA2vFcoq9uhcCdapq8HeFW2MoQ19cPq+v2PqtjpTkUg1SpJTA2gV4WZCVSVIGdGkMXTRaZ5RhSl/apGMno/dzGWbLSCHO9bhurpY9K27RzQhWTNmHgIEJEiRaZ5aVi1V4alSYGLPLKwFCuSyQQu/AQYKxTQ6x9mlDyqVAVIYgQa5+NAS7C0ie7kIliJFNsdS8W2eGST5BlbId6jw3Qx8Jp5OQxlTbSlVxTT56rqilJUhdXwiKvfBhZcom1A4INV/LMUmSVdhJLtwhGH//5rtrjyDSbSFRrvaXvC4QrfXRKlvPHW7ygiiAife4JdU5MBodqEM113rgTyzl7zYy6ijI0YYrl3m5zzz6Uvm/3xZwCaQ59XORcxp6qMs9l7LVj7d6NwKCZy7S0VyubWZujZTO2tI0nzYwh1X3ld8i+jtNRhWnVBUq5j/dBeKbW8c6Q2etaMml1fl0u1iN4a3/mMzLk64WaTcYaMUn93gTIknrcp0rEJCOixCq1TFcv4ziO4ziOcyPwNyMcx3Ecx3Ecx3Ecx3mq+MMIx3Ecx3Ecx3Ecx3GeKjciTMNxHMdxHMe5Kbye44feiEuDbpdLXPY+pJ9FwfLVfZs82vKCq3TtnJb2NI8reZU0y3KF8PA+Oj32UtuwXcLwpZb+3HKljeQk7bp+8mj/t0wIPaR0y7llR9f7t+Gny7GlP4ThJO8eBL0t87p/rqvT2f4+LdtyHbPU22vpz8ddlnedJmN22Fzz7uX7+Y7feD/f8Tfq7r/xEUov/WY9O/X0Ikt7mU2cX252e2+o3gJgCHdI+UG/brYjZocarnq6FOx199G5Y9t9QgBRgt6p172NiCIE7h0+AMDl9Dubti2hn0t/iuyWfqx9JxI3IckqY22HuR7Xkma15Omcnr+mHg/H34xwHMdxHMdxHMdxHOepciPejBCxLj+MmhmrjGwfytOYJgxbC8p2aalalIzWJ2XH3CR+QsqL7CwqG/EZFAlhMoF6jpERjKluz1mrgHI5J1SBWhO3Nfma9uPW/0F5xlbEhdaf5ZlBwkh1z2xWpX2LPDLZIrYsZYNURZilfhCtySCX8q2ll0OVCba2beWLJ5K7qJmUy1lNYHmsErkoRsxaBZYnda35Ntnm0MWSReIJ2q+VkVp27XUcFI61glqf5+1U2NeHebeCcRFzlx82qWYTQKo0QaRt2h9b+j3ZIqrs5Qvtmkt5g1gX0rVxkbKQumS0bDcXYUvb+8ekyyubmC/VfV12iVwR3GWMLJlEHetMJCaytbE/ISjZirxVJJRjskgVk5VzmhQvU8SO7Xiun3X1xLzJER/6rQelt6K0c7ay0NbGyvIsuUhgV3LQ+p/VELwi/hPK/TnnJQ9Y5IF9nJuSpdZJMplMtuUp9voJ76mActmfyE1GKZlsuW83ueW5c1saXW2vpZrr7XW7n57f9Kbnr2En0k4hEjb5qAmz1DqLklnGTinfuEnfrt3u3WwBs0UwKghzPv1eQhhWc1hQQ00WSWydr8fVxNPu2ctUxtj9Bxclr35PCUOcMROmKrCcUtjMrVDuZ5VlzA0KUYS8EkkGOT9qm2xW6rywzmNU2YzXoEXG+uxY2urZYWZYyYonE7I9/O4wKyLc2Mfr8rmURwimDBaJ9RuKWWayZaKsxoYlchXYzgSkftPUxtPr+ftnx3Ecx3Fe3/ibEY7jOI7jOI7jOI7jPFX8YYTjOI7jOI7jOI7jOE8VfxjhOI7jOI7jOI7jOM5T5UY4IzCYa+ywmDBlJYhxTCXOdrKyvV/Fmq+9B3LiQGgEtR5vuzgEajx/VpJp8UNojcHOiogxV3/CXNPG+khnr8IYitNgHxbfQFTbeBSCGEFrjLkJkwkhL7G/IsWR0M7pZVyVtcUfb1y5ZhvngJwEE9vJ/hbPHFbtE1ex4K3tBjG0lpdad9Pmeij/Lc4Hep2znbgqVlHnWvMt12kx8Es8divrqcMDIKqwr9feheIPmfMS7J1NNg4IZVs/lVLOpTxSPQbWXROCbdq1eRBazHlGSFmZZTHRTjl0d0kjVyfEentps+KemK3k13bMefFGtBJmMpMUG3Cy4otYuxAeF6smAVk5DNr/9OT5ZDOZ5GqZaOVpiAihntK8K6dPOEVKm0JpZ8U2zoi0boOaxlb9iNaxVTOebXuddeT+dS6Ikm6xVwiKrvoP6L6JJa9EfsTntYsz4mr6TH7JNMs1ry9/mRN09bnUZtlXHNBLHoqiJ6O57m1zV02Tab4dQWTdF7UO1VHTPoew7ecg25I3z0e7p5qXpvtRTJmmgZyvtkWqvp85h824aHPGqJmLWK42zoF9kM3csa3r4ugJ3RlRPsdaplGFHJa6hjq/3orGqMs4VbHuzDFr7pilTVq9ez2yMiftLpu1573kKYTq/mh+IDUlSiRRHDDlngz9XlVRsikiymA7AA44juM4juPcTG7GwwjHcRzHcRznhnDdEnznlqlb7z89T87se5zjrwfWdXxa9T33gLddN13Zc5ZzBx+n6C+V9mU1w2m9Tpe/vO7LgtMvCq5bmvRqoa7seeiqo/NDDj5aFi/N6Rhat4lhHB/tnP6lmNVDwrZdijB+W+r2JdDE1Xt/SVVQRHZ1Sc3yxZNh5Quok2VdlyVR88kSljuG+CbetvsX+cY3fwEA//4X/hy/8ME/xLt/9U0A/ND9/4lsl6slPZevAlu/CkMVxF+ujp0jk/N9AA75fi/z+vj2GoGgz/TlMdsypLYpQ22LvuRp2rSSMZcv7dPHgOVnabG6AEPtq17Hky80e5sZvW1bu7elPmfuXynT1XZ4eV+UepiG4ziO4ziO4ziO4zhPFX8Y4TiO4ziO4ziO4zjOU8UfRjiO4ziO4ziO4ziO81S5Ec6IjCySQqqATawL6A5ZGcSYQotzEbJJFw7CIrFsP0MVMzax2jELoYoMG0EyQXIXPgbNZJMeIdOkaaEfpwoTizyxXWf9xEdPfuaVXC32c4Qg0uV5oUoCm3CNDIMWmeNQrWuTSZWs1fxlEbGto7GEpY5Dve6wqrOeEViu2yRXkeXQ2yBgclX6qLJICfUkuq21SVBbhU/JlXK2dmhtoJR6jzXkbB8ygy7iy0ApR1z1dWuPJpLM1qLAzgvvSnnLue0cORFhBrErUtTSbvlEBpqZa+xVFiPVtp5aPmrEE/FejbJ7KEW+SK/P2eMb6V1AbFGiNg2i1lgyWfWc9D6TWueahy37Qz0viDCIMDaBpcAgMIZlfGXaeFvulSCL0LAILKW3ZxMcisKuCz+NKS/325zruF6LFk1QWeqopiADtpJSmuUudwwMBCJCIFqs18nkjRgzbGWTBm0aWtpsK/2ULoTMS1lOfrY051j3xTpNINS2b3mVvlrfNa1vmmg0Wuj7AWZJfV87b6i/Atp2oPTpUC8dpPTJRkbb5pWTecKqjDJZ0ZUKy9wodf+hyikvj2Np0tU91vI7TlVgmdr8txrkmpk19zlrUCOu5olk2xtiPQctc39mp+VfyUOZ8va+CwLjSjycTMhZu7y457tql2wlmtW65FKuzhOsvgEQQVAGi0CJFw1EZpaY4SabPRWbbsfm6z1e3nEcx3Gc1yv+ZoTjOI7jOI7jOI7jOE8VfxjhOI7jOI7jOI7jOM5T5UaEaTiO4ziO4zg3nevCih53/6Mefz1g13x+Wte8qZwuiQrbJRJPl088PXuJw7NVaObDzjldJvPJ8bAlXtfL5Mrq57pM14UqXx/C/HjnnFv28TSdrNJyJb20pSl7+PkO1RLiGXQHQMqHmraEoGY7cHt8J3fC2wH4o/Z5vHWMfMNn/j7PH8rSlN/54+/i/5h+kruHD9Zz7nMe68taoorKSE6X16Rd6r0JOhdFah52dtnLTLYHBL1d65POLO9q0ANw2/ajYCdj/HQ51/W4WN0PddnP88uSboJNudp3Dxs/1+NvRjiO4ziO4ziO4ziO81S5EW9GCHSJZDwRpwEryVgVqOUimcwmfb/KTNTMoOWJzzEFnhkCl6lJL8s1Qn8CZ8iJ0LIxVYnZMSkZiF32JkQt4r4mm9ypFVEjLY0RdBEdBoCQSCbsQ3myNygMIr1mcSWlhKWcKtsnt6fPIA1IdvU56EYUeaZ+D9t/jkxpv1NhZZMrdpmlNbFkO0c2ZU4m/Zx29bUgrggtl/42E9JKbHgqcyz5F8Flyovo85hlNTZWea2FfKtWSlkYwtX2SCYbuV7QlSSPJictNcxabjYRY6rXvkwtn/oTYcrCVBtlNts8C+1lE+0N1AWdTcwoAyJKYOiC10AkM3ThXWAgMV0rSyzb1GfSTWwYigQQYahpd6rsdBFY7kIZ961NRAytYtJ2H61Fgtch0kSwNZ9aUbUmLRR2KlzWSWGQIgHMGLE9xRZINm8Ge2uX1iY7u6hJmxQyky3TpsWiAV2myEzGLBOIRZBZrxMtkms/R4slv7of6BLTRrTIYMOVNodl3Flt6yafjARGAnGVl5SES74ISibaVpiZ29iwQOxjoIyNvQRUhFzb9lYI7IMw6krO26Wj1PYuItbTZ+Nzv5fKvbju5WRwmYUXp9L+++OeKYd+XwY1jjEyhMRxLu12bxpJJgwrCSkCUTP7UPbtNLALy71Eb7/lulNWJlOOqQo9RTlk7ffhlEvZU71MVBi1yVZXY5lybYDRSq3HevPeigKzMqyFliuZ5bJv9dnO3wenssrT7bIv9X51HMdxHMe5qfibEY7jOI7jOI7jOI7jPFX8YYTjOI7jOI7jOI7jOE8VfxjhOI7jOI7jOI7jOM5TxR9GOI7jOI7jOI7jOI7zVLkZAkuxLiy7FRKjZoJmbscJKPJBEeOibh9z7DJFgIs4cWd3yX44dqFYrPk1+WHQQDZhr00EaETJVaZ3XpgpYoxqXIReUvZqPDtm3jQUo9qomX1YlnMJmhkkM9TriBhTDgxiXaZ5e4rcmxWtRsaowiCLGBAtYrZ9EHb12nOV1g1V6jeqdOncsBIGDmoMVagZ1IhivSxt0RZZyemKyNPgRMS27htFyEIXDEp1VUZZttWsS0jX7adNPimGiqGyiPMWkWeRJY4q3Iqwq303howCUxfBCYp1CWmRhT6aiFPk6uelDWpetT5RMkENxYhViDqYIEIXpAIE1S5uHLJykIDZIrWbsjDnlYC07m97oggRRdG+bFGQgWADJm38TkVo2csaCQwEGYiUpY+aYDHYUNs6g5W8Sj0X4WETHA5S1JU7bVLYKv9DCLWBLoJwKwq3YqnjPmT2utyrpXyL4BQg1vHXxqSKbcSlWYqwNZt1eSPAbNLv1dZ2+y4lVWIKJMtkKVNakfvFKysZJcocEWzYiihru6yVqop2CWXLc5Z5s0/r/9p1BCVawIiL/PJkCAYigUUmuZaUtjpnSv0X6agSRfv90O7VtUYyU6yRcxfJSj+3bOf+uYlJBy15thLsa582aW6XVip93hjVuIiZsfbzUKW8rX8u1Qi5qDjbPXM6D5nBnJWUu36YuY6xtfQxrOanoJls5R5vaS5iYD8HXqzZ5BOnY67jZsrKVPOPkpmz9vttLcltDHUc34rLPC6yXFcpcuKpjsHbsUhxm+Cy1SNo5qLmcTsGDoOQrZRjrjeFJfoYSZZJjBzlWHOZq8a0VFDQzf3uODeP65Y+fNjSgy+1HOG5/B61HOvlD19vbJdOXATJabX/pUS4N6Vd5GSr/j6hibCvjh2RgMhus89sOpNzANr+UJZ7lPZ3QAbLZ5b+fBLtdt3SmA072XdWW38m3/U4aJ/Xv2cyp2OlLLlZ01he2rn+XVmWpwxc4aTdyr52rWFzjaC3UdmR8oNau0zKl+yHt/LW4bMB+MrxC/hT77zLl3zmrwPwOV/zUzC/QL73GwD883+855d//1N596++mZ/K7wPg7vEjpPwA60toXt9XxlyreJ/M/V4/lR1G3oyX9nmzhOf6F/w1V8AyKd1dnXsu/Ssxnk7n1PV2vrLfzl7z3PKka15eOf2vGsdxHMdxHMdxHMdxnir+MMJxHMdxHMdxHMdxnKeKP4xwHMdxHMdxHMdxHOepciOcESU+t8SzXMSZ23FCxXhmLHG1LZZ3V50Rh7mkbXHqt4cjb7r9IrtxcUYMccZMmKzFU+9IJt3vMIZEDHnrAJASN9VimG+FTBTY1aDjy6TsQ+a5cebZoZRlH2bGkLrDIkgmSGYIizNiTso+DjxIJb7qhSFwbxZqqBKDbp0FCiQtXoUWvx+lxPd030H9mY1+7ea+6C4ErkaPZUBNelRQjbxfoomsxEbPtR1TFqbmfViUFv1z2y5x3jWuJcVpAAAgAElEQVRPKa4OW3kAcs0rtTQtBr8WMIowKOyD8Uxc/CGweD+ytfj0Fru2cl+sYsqDyNKW9TpBis9gXebmmxjE2IfE7dqnF8NErN6SMZROGuqY2w/HnkfKyphib6f2uTFl5Zh1FUtfnBnHGtu+V2FHZGd7Uh0MR4HAsLgPZChmASnnCMogewKxuw0GRrJlIiufgiyuiOaSkJWjYJDihhibM8IM6f6O8vNWFJ6JcLv2x+2Y2GnmdmxxeEsdW3z+oJmoud/PIsZFCpvxNVQ3wGVa4g2PWRe/ixTXQBuDxyyMKZDJ5BaDyFjaTFrLZqLFpX6MDDYSLZBr+2fL2En8bNhMkcUXIatnuNFidUAU1IRA2ITNZSleiVzzjhaqBaR6QFrdsR7XOnTfQ7u/lVEXZ0Sy5QKyEp5MWRhXJV5HBU7dkSDsaozmXrXOL61P4U40YndFLPdUG6dRjWdi6v08aiKo9T6FkSiGSmBcnf/skHhuPACwCzNjTH0+DpIZ4syw8utMOTCmxFj3hZr/cV7GxV6H7r2oHcCjIKv5VNq/1WQYpMzvz9R7/nac+rwPcJkiU9Yeb3zMY3EOhWVOaHPBm44lj+dj5P4cuBVbH5Z5bjZlrr6gROC4cplkEomJVGNRk82kXPKd5NBq80h1dhzHcRzHea3hb0Y4juM4juM4juM4jvNU8YcRjuM4juM4juM4juM8VfxhhOM4juM4juM4juM4T5Ub4YxwHMdxHMdxbjprr8s538mj7lvnJw9JZyf7T7fPnXvqnpEz+24Crcxps7WQruxZOG3Lc22r9chybO0+2pbEtmnlId+F2tbd1PJc53HuOraqofW62eq/VwqF2ZGX8u6cP3e7dylLOFveK5yrv+WHt8uGli4/ZF/rn8AprX36sevKsz520i+qxVBlq/0ise6bN9siillGZdjk0fYDZJv6eS3f2e6R8/1a1tKO9w8f5P7hgwC8hx/lPR9X+IVahv+t1Wmq+f8kiG5cX9kONf/ppMKtn9Z923xsgpGwem6yA+dRpNYx6B3MZqS2X7YZswNmiXW/GTNs+uhx5xup160eMr2NSMRsZk6f6OWqVsBen9KvdVsGsIxI7OWFbd+WdEt/GRlB+0+AlD/5GOVeeKIPI0TkA8Bdyow3m9mXiMhbgO8FPhP4APANZvb8Q/MBxioP24fEPs4EyV0QNoYZQxirwHI3T0RNzFUE+KZb97hz50WGYeoivRAyD4479pcXPd8pK7Fep0kX5cyAKCLLck4R8lUZXDBGLdKzfZWY7eLMoKnL0YIWgeVuWG6C4xwJalyEPQAXIbMPgeNqDGQWUSNANtlIIqEI0ZoAcsql0UMVXUIR18W8iOwkC4vWsuSpVezW20nzRjQ55SY0lP6ziNjkdG7ut1qQRajZDrTbogsrKddodTp3G0q9QdtYaAK9Vlarn8ewlo7apvwiSlyVpQg+iwB0vzpPAK2Cu1Ezd4Yjt+p428eZIc6oWJemNrle285V0DnWMs4pEObSrvsqZhw0MmpmtxJuhqQcQxtPwiiBaGE7OZxIFq+jCRPVFD2ZjK0fBWQiW1HlZZo472RqlHK2inRZYBTYhUUEuNPMqJmLWudBE1MOpLw0+KCZMaQu+QtqHFPofZhMGTSRsnJZhZ9TVi5T6LLDbAPHKFzWfEcVBlGOtv1lqqv6NjVnb5PV/3L/Qy2vW6Wet2zPMpfjtuSdyZs0iKJmZFla2E5yLefI5g+ntl9X7V/K2Y6dpt2KaHudZT1HGBlj6H9ItPSySl/klbva2fsAt+Miwt2HRdbb+nnQzD4knqn3w1BFrmNY/sgI9ZdxE1iqFCmwSPvDcPvHWZPs5tUcFzQzQh8rMSSmOaJiS3rK34S92icCXBXbiGzX12J1yrp1tc5Xg2Zu1/v5LRf3uTUuf3w8mEYup6HPKy9OgXtzZJCl7YaQSHnuv1MAjhmOddIr859xzJljHYMHJhIzScp1zXL5t/7DxTJG6lLbm/h/kRzHcRzHceDphGn8STP7QjP7krr9HcCPmNnnAj9Stx3HcRzHcRzHcRzHeYPwajgjvhZ4T/38HuDrXoUyOI7jOI7jOI7jOI7zKvGkH0YY8EMi8rMi8q1136ea2UcA6s+3nztRRL5VRP6piPzTF/ODJ1xMx3Ecx3Ecx3Ecx3GeFk9aYPkVZvZhEXk78MMi8suPeqKZvRt4N8Bn7N7uYbGO4ziO4ziO4ziO8zrhiT6MMLMP15+/KyI/AHwp8FEReaeZfURE3gn87kvmAxuB4pQDWYRpLsVXMYJmYhXnqRrJlLFaWcfxiGpmniNpLqa2y8PIi4c996YiWru3ygtgkirWq65QKEK1bLIIyjQzQJeyHev5KSuXtWkzQgq6yWMtNDMTphw4psCxyiGPWThmuGyiM4MHsxBWEsMHSbhMiwwtmRVhnW3lbGvakbX4MgPz+pyT81NWTGwjrGzlLtuQcpVPXnPd7lqVq8+UFnHdIqNrBIGhmi9VjH2AvVoXJL55/wDB2Iex55WyMKzaV8QIaj3fyzmSTHufpSqaDGJdfJmyEHQpyBgSF3HqArtQhX0AWq8VNCNYz1cBxLqJcK46yJSFuYoWD1mZszDUawWaULCNFSlCwjOP4prQLtlEkKFLGANKtoSIIlW0eiplLO2dulQ0U+SMgUiwUI8bWRbJopmhWtSHcjLE1mJVEeuC14s4sbNFVNna6WI4MoTFmDylyFSlnjmXvjGTckNRhJWbslPGXxvHyUoTzSRmKe0wyZFM7pK/TCZLJlXDchOqZ8belkc5bqzAp0LLiZKnSWawMuZmmTdCy0QGgcTcz51l3sg0jUjG0JN7LWN9nmiSyaZezAaDKVYH8myGipBOrLHr7ckSmdKXAEdSEWeadYN2ssX33f4b1BjqGNyHzCDGs+Ox10DE2Gm5J6AIXXfDxK1cOixIZtTEoGMfy00iOVWpcO2WRZRbx8wY5kVIW4W6spo3ylwZeVDn68ukTFWi29oprJo1CMT6+0H7vVnK0u67QYwoQvUQM2ipd6yyVSjyzD4ugTkHLtPAi/X3xyenwN0JXpgCdw+7mk/ico79d8tlUqYMc5f0Li3fLOF68rJiJpVxWK3f9lD7veM4juM4zs3iiT2MEJHbgJrZ3fr5q4H/EvhB4BuBv1Z/vvdJlcFxHMdxHMd5LfJKvfT6UvmcHn/c6960l3Pb0oDtyayeWcHp9EsKZbvU56O02fklQx/WWvYoiR523urz+Sy2dT5dllJk1/ctSzvWYwyEcKvnpDIgoszpQU+T87E+FF7OMaaTZS9zbev2pcLZb5ReuqKvEKerV60v1B+Jn73uuu3aGnjLMcvLqoBluUr68pI9/emqf5vlR6/mWfIoD/lVRqLuGMd3ADDoLT6dz+eLLz6Fr3jb/X7Whx/s+JUXyrk/dfyNcp26ItWb89s4yCV35Xk+Pn0AgMvj72F26GUtS1Werqu1lJh+JKCyr9ttxaurXxC0cTWnj5/U8brOlf6FhF25Dx8FA1Ivy5yOm7wLefPTUMRy327LnZYini4R+ziD8uV9YfIk34z4VOAHpHyNGoF/YGb/RER+Bvg+EfkW4LeAP/cEy+A4juM4juM4juM4zmuMJ/YwwszeD7zrzP6PAV/1pK7rOI7jOI7jOI7jOM5rm1djaU/HcRzHcRzHcRzHcd7APOnVNF4RDLjfBHcmzFmJmpmr8PEiBcaQiFplYzEVWVkVluWs3HvxNnMKHI5FPHf/uOP3H9zi+br9yank3+RiQYyp5h+0xYqFLpiDRcrWmExISZlN+v4xJIYqUGv57jQRQ4mJMqMLLO9OpTsezML92Zhyi+YSDlkYa/hONrhMRXK5yNC2KBC1CBGHWphRjX0w9qFktFNj1NzL1ggrUVsXz9kiuIO1tLDEQ80mvQyLgK61gRFWbTXU67aIMSiRSSVP6dvbKDfhIsBFzNyq8sPb44ExzuyPcy/rnMNGeKcYMaReprkJ9CpmwpS0ivJq3bJgNcISYAiZIcwMVWa3FlU2sgkqMNdx2s5PVVZ5TJFjCleEdpdJiVWkZyLMdjWSM5O7ZNFI5PpvOZ5qzBuYlLTlXxVydpni3PMoUrzaRlW4WP5VsSGGroSoTYRYpInlvNngkITLasI8ZCVU8SvAPiqCoWIbeeAp2YRc77VkSs5FXNjyOaRyf7Qxd5mUQ4ZjbagpG7O1Vil1bLLJFjfY2nCyy95Oalollrm30yxz2X+GWebSputQXCDLEhfZPjcZJsBMEVh2OWEN551WmeTWPidSy3bOQOCQq9C09QVS5ZRLeUs7VDkrmZlErH16YEKQErNZy3vIuopWhCilfXMdkzEbIVidT0p9VIwYcpeSDnFmCDO7WK/b582tUPeYlUO7P7p8tNZP65y9+pXU7su2b87Gg3ngco7998EhKZdpkf1O2cp4buPWyvgqwtNFhguLKHYMcIu10LJILVPWPgbvXu65DCMplzxePO64Nw99zr5MwpTLPHmoc8yDeeDeNPKJY5nrX5iEB7Mx21oZ2iJVr4/JzKuYVLNFZpnPxKq+ERCRd1Bk2Ab8jJn9zqtcJMdxHMdxXib+ZoTjOI7jOK95ROQ/BH4a+LeArwd+SkS++dUtleM4juM4L5cb8WaE4ziO4zhveP4z4IuqewoReSvwfwF//1UtleM4juM4Lwt/GOE4juM4zk3gQ8Dd1fZd4IOvUlmch3JuOcFTTpf2e62zDqcSHm/Ju6fJ6eKX6SElXS/9t+6z8y9OL0s3trOHK8tnLge17Gs/T4+1c9bHRevSiKtAXpuX9K1sNoNE1uPHLK2WSKx1bjGBLdTV7l/bbUYiz5cPr3cr7+ocYUA0nqRftlWGZenEWn4RResSli30zmzudW7LiqZczgu66+naNkDOcw/JPXtOngk6knJZ7lE19rDeUk4l5xmt5TfLiChm+Uo6O+nDoGNtg5JWV3VuYaqDXpTz0b5vva0y9CUpk82oKKM+s7nO3eNHAJj1wK/J+/jFT3yS//Hjx3qd0yU21wHg8FttTK/7rKXt7fmw+3g93jPZ7l+bsqBl+Vgg6G1gaUezmWyXtYzbxWrtoUtins6lp+Vdh823sar12tNJ2pqmL3vbxtv1/dQ/r9K3+pyOi5Q/+ZB6XM+NeBhhlDhmKPH8yYR9SN1rkLJyMUzs5nZjCylrj+s/HEcOQDbt8cxzDv18KHHE2WTlQoCMkBFYuSOybAdFZomRbmVLJsytbCY8gF6WKNXTsHIOJBOOWbk7l0H/yUm4Nycuc4vRLg6DFuNvQLLVHEsZioMKsRYvKuzrPdRioXdq7DT3NKHG8oeNYwEGzX0oai17qPWZalpbxV+LKFOWpT9qwVobDPUaoZcjM9b48yhLWrMlJh6UIBCk/WKBfbDiuajuhv0wFU/ISC/LlK46IXZx6rHpmq5OOkFCcRWs6pRMemy5VIfGsboeROzKus2HaejHoHhKVDNTqh6QaeCYAvdT5MHcYuDlyp9h6zEptf0V7RNCsIHA0CeLLKAEcptva1o584dE69X2U0/+qMhSzAoAU51cmk5kautMrzwSQYpvQOskvw/lnlr7NAZta3vXOH019ikQQ5ucpbdNKVuJ7Y+S+eRUOvbBHJlMmGolD6mMt3zSlYJ0x0L3M1jrl0xiWqWtFgfT4nmo56it3A5sJ+KSdtsfANGWabS1rZGXdu6Tv/Z8BL3WE3GOsmq5reaAIq6wagc5Tbsuy1x/yc2SiBaYyWjzZFhxGDT/xpCFy7Ru29Iv91Ng3/aIoRiH+utjDDMpa3eqHFNkzkrKwrTyb1ym7ZybWebblAURGG3uxw8pVhdLuw/hwRQ55sUfMhubcaDXNKWsvCUiW4dNEGMf6C6dUY2hpr9MzQnR7tly1v058iAFPlFdQ588wr05c39ePBMPpoG709B/d92f4X7KHFbzOsDBUu+j0uKRweofmpJBIbGr5zwAyvga5VYp2/kqv175beB9IvJeyq+FrwV+WkS+DcDM/uarWTjHcRzHcR6PG/EwwnEcx3GcNzy/Xv813lt/3nkVyuI4juM4zh8QfxjhOI7jOM5rHjP7KwAictvM7r3a5XEcx3Ec5w+Gr6bhOI7jOM5rHhH5YyLyi8Av1e13ich//yoXy3Ecx3Gcl4k/jHAcx3Ec5ybwt4F/HfgYgJn9HPDHX9USOY7jOI7zsrkZYRorWWPiqvRvrmLKtWAwZSVWoVquckKrYkso4ryomX1Nc8hCsu3TmZJeurQyZyFI7hKzqYkrq0wt12srdDldEVwuYsbURJa6to8qh6wcq6BvzjDZVkyXbfGnZitp1u2gVfYYq8Ft0CKszAihCSvVWPs3M2yknQogtsk3UwR7TTx3KigUigDORFbllROfbbl2E2UGsZ7H2gFbxHLS02QRbCW4bKzFpdmEy2MRHTbRZKbVx7q48tgEdFUmt5ZVTjkw5xOBZdYuWQw5F1FnrZ9KkWiq5l6WwxxJpgRpYkBFMA71uocUOWbl3jRwr4pKL6uIca79bsJG1JgMZjNmSSth5dZwbJa7vBKq1ZhMsgmqqfkoRxJTFykmm8gkpEk9pckjF+nixIxapPmfk2WyGSqytFMSgghD7egHczP5rizS9WcrcRBjp2Mf/8mEyxS69K9oGYv48t7c5IHKZMIxleveT8Ixw7QaqCpCtEUs2VSW+WS2ULbSzrKvtgu5CANtu/9hnMos1bS34/rap3nZ6ui6/9rnRcBZBaAIM7bNxWoeq/GQgdSElV2muQgtZyn387GmP+TWHiXnMUuVWS7iWBUlTkOfO/chVd9ySTPOsY8JgBenHXengUMKHJr8V4x5JRUWsc09jcKQlPWvpEOKmNHnrCKWLfdpm0sGNQZd5rhyTJZ5ReiS3nZvBjWC5i7UHbXIQS/q/b4PmShG1IzWtktWlJ+tzOu5GIpI0+r+1htTLjLLtRQ5iBBrhaTNdQixjst0zcoC7Z7PNpHyESMx17vzterzf1KY2QdlK5J+mIbccRzHcZzXMDfjYYTjOI7jOG90PigiXw6YiIzAf0IN2XBeazzKY7Kb/BzpcR8DbpffO5+irJBUlt1rf57XB5TtwbReYPnByYnbJS7b0oKNsuTisoxqSneX8+oKRtYfpa5Xk5L+MLuV5XR5R+N4fVOcrjB67tjZz6fLpgpY6mWTur6UrFZfQiIiWpdTLKgMfcnKnFs9E0Lony/iWxhDWUryQt7EbAcO9mLPY6hLHj5/+EDJxyZSvoeetHFfurMtQ5qXdppfYqz0x+eiZalUIHGvlLOuVpbmst2WgJxTW0JRe1mS3S/1q19EzekuIgNT+kRPM6eTZVLbUqWprvKkIzkfN18qnUN15DA/Xz7LCGQSy4NzkYjKwIP08fN1lvbF8NJOMVwAOy7TCwAEibw5fgZ/ePiXAXjXM3f4jNuJT7u45NdfLP3yMx9LvF9+m/uUc+7lj3Hv+FGyHWvb1uuQV1/c5JNx/TDaF0IBCJvzzt0f5R4pY2FOB84vX3x67bBK81I3yzmWJXxh26ZtLCxLfLYvqbQubbpaPreUfrU8bvvS+Pz2et9S/pe3VLOHaTiO4ziOcxP4C8B/BHwa8CHgC4G/+FInicheRH5aRH5ORH5BRJoI87NE5H0i8qsi8r31AYfjOI7jOE8JfxjhOI7jOM5N4PPM7M+b2aea2dvN7N8FvuARzjsAX2lm76I8wPjTIvJlwF8H/paZfS7wPPAtT6zkjuM4juNcwR9GOI7jOI5zE/hvHnHfBiu0d6+H+s+ArwS+v+5/D/B1r0QhHcdxHMd5NG6MM6IJysZQpJMXcWYfSozLoJlb45HdUGJioiZUDK3CMm0ySROC1virrOzCzC6UJtilwJTpYrTrsJXwMZlsooGUJpI01nqtxCJ9VEo03Dmx39iEakHYqxLqdfZaJIHtuJkwhXbNKr00IQqEmvE+wBggmzE02VsVubWyRCkiN12VocnebCXlBDbSyrWgM2jGssJKyDlnZV41Y6h5Dit5XWkrI9XzLBdl3yKmYyN+Uyl/Oc62iEOnKj28N42rdHZFRJlNuD/VOLx67lzljVFyEc3l0M8LtUz7Gn+lKEFzF+mNOpNrJNoi5AMx61K8nErk57pcrX0bmSa8q0K7k7gwFYgixBwINX4vWua4kiaKnH+eqBKuSBNzjxXbxnQV2ePyv5K2pJJqjm3yRLNFXKhZGPMi3DxkCEkItUxK7O3T+nIQY9bc+zmZcD+Fnkc5r9wD91MTxZZ77lDTTLnIPdftVM5TojURYGSWuddHTTFJvd0CQ6/34l2NRMubdosWi9Sy5o+xaadokWih3w8QMbZ5NMlltNKHA9s3wc+JLrVLZVtbSr/XWxtJjauVzX4jnEg6p0eIy861nw2rUtt2QDgm5b4sY73MrYFQz7lMAykLU5VhvjgN3Jsj99Mi5e3zd723jils5loFcpAuKl4TpcWgGlHLXLqv7TNqZB9gp02wawRZxkSfezQzVlnxoIljWK6/0zInPhPL8YuQGDQTNfdrD2QywlC3d5oZNfdxe5kigyrPDYsUeR9n7phyrHPOgzQwqHJ/bjGs7foDh1zGxpQHJsuMVuarg9zigVxw0CVGPIUisQz11/cqavp1i4j8MeDLgbeJyLetDj0LZ6y05/MIwM8Cfxj474BfBz5h1gPPP0QJ/zh37rcC3/rySu84juM4znXcmIcRjuM4juO8IRmBZyh/s9xZ7X8B+PpHycDMEvCFIvIc8AOcD+84+22Emb0beDeArJ/MO47jOI7zB8IfRjiO4ziO85rFzH4c+HER+R4z+00AKa+FPWNmLzxmXp8QkR8Dvgx4TkRifTvi04EPv8JFdxzHcRznIfjDCMdxHMdxbgJ/VUT+AmUNs58F3iQif9PM/quHnSQibwOm+iDiAvhTFHnlj1LerPiHwDcC732ipX9D86hLW6ae7urSeY11cOw5TpeXexQ92nZZy6v5vNwXYtZBu+eW+Wv7qXXXstRiix6qYY+iZSnDZYm+ViqrS/St8rW8HKME811dgpC6XOa6DFfbKYZnAdjFt7ALzzDnS6a6tGjUHQ+mjxO0LBuZa9natlkm20TOxx4eajaV5Qbb8oNSgxA3IaeKrZbtVB0Zwm1y3dfST+keWpcuzDaxj88x6K1+3k6eqQtOwiB7AJJN3M9lScoH08e5d/wdXrRl2c9Q27nU/TYpH2o9jkv5Cb18MZQXtQYtP98x/ku8M72DHZF9XVb0w/YJXpQXeEt+KwB39S63820+oaUcAyPP5md5Ti54sKr37+nHeGf+FAA+Li9y2/YcKG38Ef1N7vAW7std3pzfVuprOwJKrJFrd+U+7+BNfFB+j2dzKd8LepfEzGfYO2p7ZEYJPG+lT98ebvN++yiZzLO59P3n7O5wb86886KGwRrcinCvFvVTdsYxC/fnJUTyzmBcBOM3Xiz9+rHDzMEyd2po/MfnI5++33F3yjw3lnw/507iHfsj92sI9u04czvOfP7bPgLA//tR4Sd+9xne/fu/xUce/LNSlnyP8tLbw5bGlJPtx7mX2z2UNtuPnsujLF/cgrZfKVZltKvlXq65QvTKvCFX2u1knyhSl4ZdQmxf3nLNLrB0HMdxHOcm8EfqmxBfB/xj4A8B/94jnPdO4EdF5OeBnwF+2Mz+EfDtwLeJyK8BbwW+68kU23Ecx3Gcc9y4NyMGMfYhsQ9zF5KNIbGLE1GrcFAMldSFa8MwMcTyCG+uT9yyCeM0EpuIUYx59cCniM8yg+aNuK0dA7rAsOUxV8mbrmSNLd363KiZ3Ur4mENiysqDuZTtIij7IN0JGVUY1diHdt2MiDKoEHWR+q2fYZX0VcSoTQq5vfaopX5riWYQI0ruksJsspEutjTtKVgyJWkmmyzPJU2YsjKtpIVDvda6bWGR4h2BOQial+djKRup1i/nIjKcs/SyAQwh9fKlrKR67dZf2QRJgcu5DPVMkSE2QecsymUKXTIHELJu5HpBjGDaZXZKQJOh2EbsGXTZLiLLRabZiJoZVv1hJou0s4o92/FRhX1Q9nkk59q6CqPcYuZQrlNFd2sG2SGELkwsDb082Q0yEBi6AG+wHTvbM9jQ5YcDkYCg1dqpJv3JZXtq2r5H0VUVM6zGRlUsmpDrPtVFzghwmQKXSTey0kGMdCKKNVue6xpVAru+XxEGlLlL/dKSkJMTKeLJ0UYGG7p8Mlu5idSWsTAwkuo3FVkySiYQFxllbTOtlS5jMzDLvLHqqWkXV0YLm2/8+r0m1gWc7elz7MLNsO2PmkKxLrbMrYLWxunJ9F4bUJCebxQliDBoE00KQVjJZss9mg1SlTVmlc24bvLKdg8ds3KZlAfz0q9Ry7xoJ/eDrubWcj8tx6JkRK3P80EyoyWSKVor80IYeBC0z4PRBJUiwC3nlDlvDIl9/R0QNbFPcxdNlrZa5JoXcWYXZuJqjlYp3y2mOjaSKWMKvX53Zy37gvV57iJOxNX8em9WsgVCr2Qp62USpppoysqUYaiSy/s2src9l3LZCzrbASGcvfffAAwiMlAeRvy3ZjY9isPBzH4e+KIz+98PfOkrX0zHcRzHcR4FfzPCcRzHcZybwP8AfAC4DfyEiPwLFIml4ziO4zg3kBv3ZoTjOI7jOG88zOzvAH9ntes3ReRPvlrlcRzHcRznD4a/GeE4juM4zmseEflUEfkuEfnf6/YfoYgnHcdxHMe5gTzSmxEi8peA7wbuAn+PEnv5HWb2Q0+wbKsCLB9DjavX6mbg5HMpr21+xpDYX1wiYhwPxfL74DIRNfd4/ZJWtnHo1QGw9j1kFjdCpsS/t/jp2cr2hCLNj1Cv0fJozobbw7FvA8xZmWvM9d1ZeXFWqKbafYBbwbhVHRBRM1GNQZVBa2zxLBj02OPWbCps/AetHgCDZoLkHp+uqxj29lnPnKu1HYCNoLU92crVEWFr/4MJ1O1ZDFCiGPeryyGZcIcHscoAACAASURBVJmUucalH7JybxZerCKPYy4ugiCB544l9v654447u8ve/sfqAznk0OtTHBHK/bRcx1Y+giDWvQWN5tZoMfAt7ry7Qay5KUJvn+bWaL6EU1fEuX1tu51TutJ6O5a+E+LqBsjkldWXbqhuNLODkcirZ42JrYF7jaIEIop2/0BEiKL9yrk6Ds7ZdXtZrLTv3O8HI1J8EetSbnwDtS/SyThKebtvfX4QyNcUI68GZJa8aZ980laZTBbr+1va3NwgplfOOZfPGq1trqbMMm/2rews2/xWZcj9XixWiNz9HFYdE4sfIiBksz4/Jmt5rMuzRVb5b8pwTdR979MMky4Oj7RyxCTbulqaL+Zy3Um5uChSvV+mmsd6/o31vpXVfRZXtQlqBBIpZ+Y6740hVwdNHbdSmqNd2arrZO13ETGCLndHrB6cVpYoxTERNXdPxsUwEUPqzotjihzn0Ot8Ow7cm4vLYu0yEoFBmiun/Gs+i2TLvtZUqf5sbhCz0u9tLM12YM4H5vyASQ7nO+31zfdQ/hb5y3X7/wO+FxdPOo7jOM6N5FHfjPjmarD+auBtwDcBf+2JlcpxHMdxHGfLp5jZ91GfuVlZX+/lrSXmOI7jOM6rzqM6I9oXTX8G+G4z+zkRuf4rUsdxHMdxnFeWeyLyVuo7eSLyZcAnn34x+rs3T//Sr1nO/Umo9Ug9JopIeTvVbKK+X3qSS92u69eLnXsTLZzZt6z0tKw3xEu+0dfKxeqNvXU+C9e/Ebe5pqzKf/ZaA8L1K+GIRESUnI/bA+v8RPv2sjKT9jK2Oq/rvWkDGVj6pr2RVv7vgNXVo4yEELB6ncP8cY7phX4cYEp3McukvJTNLPeyi2jPV+tP+s92xtXvRC+GtzDlB31bJZJt7mMj5SMi2/OiXpAtc5k+2dPcl4+R81KfnI+YzZu3S9dtEPQ2IopK6Z+c55LeMipjzae8c9vqoxpJ+UDKJc+PHn+Jj/JLRN0hqzduZzvw0XodNSVb7it3Ccrv6b6mu1zaMmU+Wu8XrLy9aVauk+aZT/LbmGU+Lh/Y1CfU8ospHwCm/ICL+OaSf7pEZeAj9stQjwXZobU9f3ku+wTtbfzz944EHWkv2Jb2GMi2vHErouTaVqf9BjCG26gMXF5+oh9734slvV2WOskLASNtxljOR3Jtk2WsZx5v7n0l5uknOdc/ybxP56H1XKiILHPpMu+1eeQqm311LPaf15710jzqw4ifFZEfAj4L+E4RucNLz8yO4ziO4zivFN8G/CDwOSLyf1Le1Pz6V7dIjuM4juO8XB71YcS3AF8IvN/M7tdvJr7pyRXLcRzHcRxnwcz+HxH514DPo3zF8ytmdr0Qx3Ecx3Gc1zQPfRghIl98suuzX43ojPUV+0skJqQqD0uSSVnZxfOvh4gY4+6IxuXVn924Y7hMhCarW6VtPwdNRWzWZJSSSaZdSDaJdpkmFFlaAsLqNRUFdCXK3IeZfZx5bl9eQdsNU8+3cW+OXCZhH6o8LRhv3s08N0w9j8mUB3PkskobPzEVCeNlNaDt1IhiiBTxWyufwqYsrW6tTVvapfxbGehogoj9/+y9e6wtS1rY9/uqqnutvfc55947wzAMM0NmGGELHMPYmWAeig2TxLEwwljCchyCQEIhkVGAJI55KBImcWIIAePkDxMEsiaWZWJsEx4RUZAzE8dYiTM8wjshwWZ8533f5+y91uruqi9/1KO7197nee+555653+9q37W6u7q7urqq1jq9qn5fE7ldTB0pOfxiHSpQpI+VpTSS8n4AdiX/SWEfHUMxue0m4YVROB/zeQ9Jiar03nNzzNX2fOw57YZV2SWkiUCzcBRYyEHH5OZ8kGWa++jYp3kQY1To1VHcmfQu5fq2up4sAJXFvfcuEZy05WU5zeV5WSham1SW6M3LNf1yeGVWHSZSGRaVynBDd5thqzCLHOXScNgyPBNHUI/kgXnzfmhb1qJ3dEdDsBJz+0xFqHjcCpcS1SpArfvIUVmkUndWEsZSjr6VUy6YupwUYslfPbuSiEx3lE3mPOd0kKWOiTRLKMt/8Q4SyySK13m5iicdjqDr7rUet5ZzOtp2p7weDzNOqjjJQxarfHLiuO1e7quPhyyXomzi3tuJLGEWrSayxLK1l5SlsLWuRy3SUp3vkZS+aD6WNMnvcl1CWv8aJOFdonO5jncuFsHnWoybpamlDBREORpsOB9/+bokqjBqlYPmwaCdi23o6tlmz6YfmIpw1489jo7tlOvO1id6p/ROOQm5n950I4zr9h1kXW+rbHOu28JSYutrfSp9XJJYhrHOctbX00QByWNKvwJ4B/n7yx8XEVT1Bx9pxgzDMAzDeCDuNjLiB+6wTYH3voJ5MQzDMAzDuB0/A+yBX8OmihqGYRjGY88dH0ao6pe/WhkxDMMwDMO4A29T1c9/1JkwDMMwDOOV4Z5Ce4rIqYj8JyLyI2X5c0TkKx9u1gzDMAzDMBo/JyJ//FFnwjAMwzCMV4Z7FVj+DeAXgS8py08DPwH87MPIlGEYhmEYxhH/O/CTkmPOjWTlhqrqjVcvC0tvyf2GmLufc9yOV9sSUq/37rNiZOkuWoSfbGhCNfuyZn/NHI7yEhovrZrD+1Xm8KBXhfC8tO6KfKnGS2EwV34dcYC/MlznHCYy5lw1J81t7pOCMly9re0/l7fgyzlqnYuUan/7Y9S83PEcNTul7FRAQruHTjYtLCdA8Cd42XASnqQjh6EcySEXa/jGQ7yFEgk1HCXFc7UotxoydLm89U8wpRK+UTxjulg5rsZ4jnebdp7gt4zxvITznNp5DtNzqxClMe1wJS8pnV9dxwCKNyrGQ16U5T+Ncv3yi3V9eKLlb+Nv0HenPMVbADjRU94VnuING+GkXOY7rg044Hwq7h8EL8oTXSm35Hhm3/HcMN+XzsGnbSJPX+SDPNUruyhcL268N58MdKLcnHzzoNUS+/Au5/WNm8iHzj1/4ImR334ph/t862lEgJfGnPp6l/jwheesXN4n9srnPxnpnPKR3fqfiM+X/PUOPrpL3OjyMZ4bIkGEp3rHbqqeOXhumHjztmvXs3RS3ejyuU7D7AP7Z+cjH5KPcyPl7vyT/hM8O/0uu/G5XG5pn3sMveByH3m7e/so+lIp/1+73O4tLOnd2vbdzzuH7HToIlTsKmUJ7yslDGxwZ4t8zv2u4HGutqkc0ja4TdnmiDrhxBGLR3o/fPiBcn6vDyPepap/VkT+XM6Q7uRRmCwLibUQMaojFWEgZFma93GWLvYDYTPgwwRFkNhfnGTB2ALH3JiDaBaOudikjt4lvCrbIsJMZGnbUOSIIjp3CuXcnUv0LtIVWdtpN3DaDzx5dg7AdrNHVRinwAsXp6v81AbaOdi4xNZP7ZiioD5m4R/QiePiqP6OKnRokwe2yNmLclreRS9K76aVELIJPheiQRGaEDJIYsKtvqZ4l7Iss+bNJQ7JzcJRneV9VTynKigwlvtzSMI+KvvSe40p6/3GBPsmuQxMybc84rNkb5AaN1txKji01QV3LEes5YAQZO5EvVtI5ETpXGr3sF/UiUpCCMsw3kXUSD2mCiITQWZN4SHlurP1ec223M+u1jcB78CJtJvXRInlGrXFGndt/XEH6HSOF13TLkuhShdDETbmc9e1a46jwi/lhw4tssp5W5WY1rI98TELLOv9mAIxzfJAVSW4LPrrWzkoeFrb6sRxSMIh1rY258e3L6WuaCSXeZ0lkZ5AR09QT/381yKvrLJAT8h1uHwJ6RUmmbiKpZwy4Oi0Iy3aTCK19hBwePz8xUirIFToFl1ywLc7EBA68fNHjUgRH85XGI7EjPUeTsU8OZVrD4s72zlH71yru0FyeV6SqC7WXTWczktqeQku0Tlh4yC42g/mfmjjqjw3svGxHav3kY2L+TWsy/i0z18Qvcui4il6el9EkqWf9jLXBXdUaZf1rRIXItupvErtn0r/kiXGOS9nJzu6bmJ/KP1RvPqjM6rMok8VxuQ5FEnvkIRRsyAXcpOe++T1cerHqz9qlw6Plw51iUD+QnB1jfyU5QeALwZ+TVX1bokNwzAMw3htc0/TNIBBRE4o351E5F3A4aHlyjAMwzAMY83vAL9uDyIMwzAM41ODex0Z8d3A/wS8XUT+FvClwDc8rEwZhmEYhmEc8VHgAyLycyx+ELHQnoZhGIbxeHJPDyNU9edF5JeALyJPSvlWVX3moebMMAzDMAxj5p+Wv778GYZhGIbxGHOvIyMAtsDzZZ/PExFU9R/ebSfJFo0PAh9W1a8UkXcCPw68Afgl4OtU9Q42H8MwDMMwXu+o6vc86jwYhmEYhvHKcU8PI0Tk+4A/C/wGs1JZgbs+jAC+FfgtoNquvw/4q6r64yLyw8A3An/9Tgdw0KR+wSX8kZBMyLJAX0SAfTcQQsS5bAQ9OdsR+hFNsyUshInOT/Q+p3GiRdw2S/NElM6nWeJYZHwbX4y4mgWWhyI+65wSNMsmT4qE7dRPnHQjJyHLMs82e7abA2enF/k8ITKNgWHsGFK+HRfRMSThUISmncA+ei6KNM3FLEq7iJ7dlOVoL4yem6MwlruT1BFE6Rcuw2rwXeJXkj3oXSAW6SPQRI3pSMw5FClbzkNo+9f7JaJNculFOaSlcFSaVXdIVVwoHBLsipTwfITzSbmIuRAmTSjKPnr2MR/3Ygrsp9Dy1PsR1Tmv9bjeJcYiJdwDfrHdF+mo6lynguR7WFN1LrH1sckYt2GapZntPAnvUqtPqZx3mY+kwuQcU8nL+RSy6HNxnKjSBHdJISZIqk2GmFif1xcTbkUWAsbb4Y6EozBLFR2zOC+XRblnZAN5YraTexGCE7aljm19Fhb2tZz8XB61np2ECSdK5+b1SYV9qSuq0oShVbpZ70Vc3Lc0uSz2XOTHkaWPAEE9kUA6uk+91teeTsNKc5nIsk9fusWgWSDpaxMpkuPlHcuCVFm5yz0eT8Lpsm2tdZoBWR0nkZiQln9pCs5MJx4v8/Kkmu+NLrzL4kiqrVw8ghNpYkst1yUIXTlSJ1m8Wro0glu7p1WzZFYUbjdLXyT3C12RqXaidKL0PjUJ6cbl9lXrQe8Sp36apbA+ElykD/kVaO2nCixFlGHq0IWsGK4WHy2vofbTVUyZNDBEz1jq3BBze4glrxcxcJICW51aHqbomaLnxfNrANw8bDkfe54/ZInkM/uOZw+C4nl+fwLAmDwvDRs+tsvm+Y/vAy+NMCyU4l6EIc7Lh5T7vH2JInBg5CAjB8lG7MiYa5J0d23nn0qIyA+p6reJyM9whWpcVb/qEWTLMAzDMIyXyb2OjPhq4Per6n1JK0XkbcCfBP5z4D8sETjeC/xbJcn7gL/EXR5GGIZhGIbxuuVvltf/6pHmAsjPQi6HnHzlz/Fa4d6vV5exXXQZom75eHAOi6qrZdr6u+XmMukO244PcPW1XLVvW9f2uep6uM26q9Lc7VqXMazmX5LWoTD90T7L3wfv7/yClLCl87FSCdFXD1fzE1OOAHcxfHg+p94hLOttOA7NKgg7nm7Ll8O25nwvY9/VPI08d2U41+WxasjBq+vVFQ90ZRnGdq6rqQ7g1sRhnGepD9OLADzL/93W/RqgN6c5ROLHlyFa5/u5XHauJ+mEtvKfFvmZ8zvvO3Ip5K6mVejaGp5Wn1mX993u199+/qrwuQ/IKszfywlb+aA8ir60RjB8kFhXLye/dd+I3qafa3kr9bmG/hzSzZdx3iUP9tl4rw8jfhfouP8IGj8E/EXgell+I/CCam1lPA289aodReSbgG8CeDJcu8/TGoZhGIbxqYCq/mJ5+25V/WvLbSLyrcD/+urnyjAMwzCMl8u9jvO8AH5FRP5bEfmv69+ddhCRrwQ+sfgSAVc/qr3yMZCq/oiqvkdV33PNndxjNg3DMAzD+BTl669Y9w2vdiYMwzAMw3hluNeRET9d/u6HLwW+SkS+giy/vEEeKfGkiIQyOuJtwEfu87iGYRiGYbxOEJE/R57e+U4RWX4XuQ48+2hyZRiGYRjGy+VeQ3u+734PrKrfCXwngIh8GfAXVPVrReQngK8hR9T4euCn7nYsEeWkiPC2PrJxsQju8qCKzieCj3RFEtn3A6GbCEUiKZIYzrcMQ894yNHAdvstYwyMKc+/GpPjkIQ6WGRMjqiOmATxsyAviy7LTEfRLL0r+XQARdLWFXHeJkyc9YcmYTvZ7tn0I67INqcxcH5xxs3dCc/vs+hsNzkuJhjaNC3hucEz6RzJbErC+eS5KMLH5w9wa9I2z2sfHRsv9BGi5mtMCn4xNqXmvUrlFJqksVJnpKlW+ZugpXzqec6nWQAI+RxOtAnjvNMmiav5qMNhDrGKMfP1XpQJPBcxi9x2ZUZPva6oNEnnkBy7qWty0N5PBB+bdDOmLI3s/HxNjn41+63eJxHf7mPvI51ok9d1krjWD026eNoPiGgrk3wul+ugn+dLyWLQj5LzEpNr8svzIv4MVU6pssqbk7rvQoQoCS06xLxtfp+vz9HRE5maMFFwxMWMS68dyEjQIkTVLK/sFscJIvjyByAqjClfUb3q3jlOA1wPOdfXuogDTkMRx/pI7yOq0kSWZ92AoPQlTd3uixA1Jod3iY1LbV2VwepCgLqPjoUHEIdkQWsVMxJIKKnNnUz1puQyIBBwOBzjYm6m4gilvfijgWNB/aWxXbWMa1qHEBAirs2IzqeVJgftCHhxTRKqqkysZZxZcCmEMl+0d45O5hrli6hSVFGtclMhMQssO5HyPpR9UstjV9JsnLD10gSWWw8br62fiDrXQ1lcuxRJJcDGT6ttXfR0ztGrsi1tb+uy4LX2NWdh4jSMrY31PuIlsenG1q/3fsK5xMk2z2n0PrHbb4Bta4udKCJzv+bIt6i2qdpnJ4RYhI+iyj6GJkQdkjAViS3A4DxTdIzJt7zc2p1y67DlkxdnALw0duyj57kh15WP7IRPHiJT8nzyNPfjFzFwPgU+echpnjkoLwxxNRvZixC11U72aeIWBw6SPy8GGRgZ2HOr5PWCWOrr3L5fS36Bh8Y/Bj4KfBrwA4v1N4FffSQ5MgzDMAzjZXOv0TS+lCya/BfKPgKoqn72A5zz24EfF5G/DPwy8GMPcAzDMAzDMF4HqOrvAb8HfPGjzothGIZhGK8c9zpN48eA/wD4RR5AlamqHwA+UN7/LvCF93sMwzAMwzAMwzAMwzA+NbjXhxEvqurPPdScGIZhGIZhGJ8CLCf1zdSpaNqmGdXlEobwSq/65VCLd2eZ9m6u9rsdz7H+He44XOHl84r4OdQiILLBSUA1ITJ/9RZx1ABzIgHBl3WpbfeuJ6Yaii8xpfNF+Ma4CBs5l5MchwBdhIis4SNFulUS1cPiftTrXYcYVT3cR9jHy+WkR+v1aPvVTvv1OZRleMz1dMj2XjbI4pqdBMAhsi6b4LdtObgNb3bv4kZ6AoDrbDn1gefijltyAcBN9xIvxA8TNU+leyK8lV16kVvjxwEYS6hP1UMr8xxmcQ7zqEyrfCsHUrzgytCvqvP725TOqmRUVsvawmkuy/9on1XIzWVYzzvdkwfhdTGl0HgA7vVhxPtF5PuBv88ivKeq/tJDydURApyWeePbMg89uNjcDcHl5c0mZ217sidshnmO+dBx2G84HDbsDxsAhqnjYti0dn67j6s8Hzl3At4lnCihzIPelA+QfczF2JU57lsfOetyZ//EdseN0wv6Ln+Q9MU3sLvIEULOdye8uDvjxf2Wj+5y3j58ITwzRIaUz3PmPU4cQ5o7mTEJN0fYxXwBL46Jizi1OeZJ89z65IXOzft5yZ6HeXn90d+5tf+hUv0PdZ71vizvo+NiWndyQp5nXuf0d04ZF3mPxV2h5T2AKBzi0gehjBoZSweeUBzCmLTN/R6TMETP1uc0fZjYLOah1/tf60d+n1auh+ByferGvs1nDy6x8VPzHASXuLbZsyluijqHfYoeLXmZJk8Isd1nyPPqfakrMTpUBVXhpMtzyocY6IZN828M0TMl18o6KUy6vhdBA1HGNl8cHF47ouS8ee2yC0LmOeXZCdGRpDoDHAmPL83f4Qhkv0Bq/oH8FaQ6IxTAOVS1rdt4OPHZFQFwPWSXy1ktp25i60eiulaWp/0B7xJduWeHqcNLYjflL0UxuVxuTjlp7WliTI6hLHdu/aG8qN6tVAKeqIlUPkxT/VKitRw93eL687ZEXJRbKF9QUrkD9VhOhVQ9H6SVD2JJXZeOPoCPl6VZPzxh4Y5wMn+1Cgt/B+TvG4LgJbtG6qWlxf3xIjihHd2luZ+r7bz3Qr9QYWycrrwyt8OLtvtQfQ+1nxyiLyUW6Eua0zDhRZuDIUgpuUVbTEi7/wDJCSf9wPYkt7euG/HFCzOWunDWjWzHQF+uZ3S5b5Gja4hJFm0m92O1L0sIU5JWj6IKk7r2+QJw67Dlmd0pnyyfHzdHzyE6nhvyTs8eIs/FHd14yktjaMc5nzy7WPvKxEFTa2O1rx5Vmco/LEYSg4wcpPQxTOy5xUD+Ipx0bP/4SPf05fRTBxHxwPtU9d9+1HkxDMMwDOOV4V4fRvyR8vqexToF3vvKZscwDMMwDGONqkYReZOI9Ko63H0PwzAMwzBe69xrNI0vf9gZMQzDMAzDuAP/DPiFEt7zvK5U1R98ZDkyDMMwDOOBudeREYjInwT+ALCt61T1P30YmTIMwzAMwzjiI+XPAdcfcV4MwzAMw3iZ3Gtozx8GToEvB34U+BrgnzzEfBmGYRiGYTRU9XsARORMVc/vlt4wDMMwjNc29zoy4ktU9fNF5FdV9XtE5AfIMstXB8kSQYCuyAg7P2v9go8EH/EhS/J8PxL6kfHQAzAMPYfDht1+y37M63Zjz27sOC/ivDFJFisWG9ioQkwyi2yhCc2qqG0b8vJ2yjK+ncvFufGRkyKwvLbdcXqyI3TVXqzEyXPz4gyAm/sTnt2d8tLYcXPKUraLqFzEiVjUZBJhNzmczGLDqLCPsC8GyDElIoq75CqepZBV0DYVQeIoQhShW4jaSGv5pJMsq9Mmd5ulkzUvdf2S5WItQz3aLqw91EsRYd62FgMG/CpNAsbkmlhQRAkhEsI6+mzfDXRhllwuJXmdj1wcNnQuNfGloJz2A12RLm67ge3mQN/nacpdPyIukaInlns2DD1dN9L1Yzuv97GdJybHNHSM42yvTmQB50WR8e2j49boOS9C0F2EfUrsGJrQbpQDUUcoFuwq5Vvaoeu6KrirMst0SUt6mWpRjkWEWJeTZtFpWogUBWHrlY3LaU7DxEmYeGKT87oJI52PJJVWtttuwPuIW0hGT/sBX44xRod3iiqtLnuXuJjmtvriGHhhcNwctZRb4qDre37VtToVikswyx9X1ujL+wlXmxyTaEvnjozlCV34zOt9iG0bcOmcy20tr5Lz5xYmRrfKTtZSJoRO6jGyzLKmqyLKtBBa1sZYD+Vl/gMIjnV/UM7jSz+Q86FlXRH5hgkviaBrgWVMjm1pQxsf6dx8j8bkGUfX7ntUh5fEMHm2pa3WOtNvivz3dIfvR5xPHIbcj1/vBs5Cz9b7chxBl9deykSXwkoVDsm1vitpFRUv7OaapZdJc59+87Dh+cOGF4a8vIvCPgovlTp4K04cGBlVGUolczj2UVbnyVJVynZlUjhobPc/9/qJqYh7a3tPRZaspGzZP6oLrxdE5IvJocavAZ8lIl8A/Luq+ucfbc4MwzAMw3gQ7vVhxK68XojIZwLPAu98OFkyDMMwDMO4xA8B/wbw0wCq+n+JyB99tFkybs9VgQSn26a4e2SYeNcUV6e9n/3u97zH4Stz2hyaU9tm1bE9wr4bgkAJ/yl4hhJBB3L4zxrWMy93JWwl7aHlHEK0hpbM4URT9b7qBOJaiM9MQjW2h/CXQoOSSDqyju91P7F87pb2TtuPQ00uQ4+uU9V8J92DlhCrQEy7kkbbuvxI+Drb8CQAnTvhFi/wrDxd0iY6PSG6+YHwKU+hJDb+BgC79CK7+Pzi+FfXlXsLh7qM65fukvYqjh9My23W3y3N7Y7zMLhTmNwSTraledC6Z7zWudeHET8rIk8C3w/8ErkW/OhDy5VhGIZhGMYRqvrPZR279eX+S9MwDMMwjEfEvUbT+M/K278nIj8LbFX1xYeXLcMwDMMwjBX/XES+BFAR6YFvAX7rEefJMAzDMIwH5H6iaXwJ8I66j4igqv/dQ8qXYRiGYRjGkn8P+GvAW4Gngf8Z+OZHmiPDMAzDMB6Ye42m8TeBdwG/wjwkUoFX5WGEAFuf52tt/MRJNyKiTSi5CSPbzYHtSZ6z1Z8cEB+hCCzj5BnGnjEGhilf8hQd+xia1Ky+VmJyjMkzxEAdESqieJfoF4I1QRlTFRDmY1/vD9zYXgBw7eyCk9OLdtxxzBLDi8MGgPOxZzcFzqfAvojPxpTQrCqb91PlULYrWUo5JG3iSAU8QlfmCAYROicrOR3k91WqGEQRgc7pYru27UAR1SljKx8HSajztTZOS35mUVs9djumA1GdZaCShXFO8n75qIoidGW6XOeEII6uCOQSSiDLE72s54o1QWbJYxfyPEjvI95HQjex2Rzytt0JKbkmUNz0Iyf7Ddv9yXzNomz7gb7L8ys3mwOhH+m6ct/7XP9UhThkqWI3DnTdhF8ILJ2PaMoXNB164hSI0TOV+lLllbsmLnXskzBprQegqqu5hoLHicdTBJbqCASS1tmoDk9oMsH5mhxOc148ARR67edlyLJQqULMXIearNJl2WNS2rrO5ft/UtrDjf7AaTfy1OmtUrYDziXSUhha0rZ71Y2cibIp92xKPktek0PK9NYheqbkGEpZDkmYdL7vXuZ632j1pqyvQtZSBj2BThwRxbdycaDQlTmnXdm3SlQdCRQisYkrPZ6Aa7LKnC6vrwT8SozpcXiEILU9qMP7pgAAIABJREFUO1Sz+FLaubK8sh71uB1Dkcsu9snlp62/Wopoc1lkRGbJpZP5D/L97L3O+yVaH1H7ieASvY9NNHnSDYSFnDIm1/rmvrSzs9KWDqX/PUTPIc2l1rmEFyW4hJLbqnOJpNLqjojiQySEia4IgU/CyMalJlEdnFyS6UYVJnVIqTB61Nfna9fWr3hRupLvWPqnixjYR9fkv4cojAliKdTaRt2inEcVhiRNIDzqUcbIolKn8z4BT6cdnfT1wKjMWtQkkSjjFfO5Xx+o6jPA1z7qfBiGYRiG8cpwryMj3gN8nuoV36YMwzAMwzAeEiLy33AHY5mqfsurmB3DMAzDMF4h7q71zfw68BkPMyOGYRiGYRhX8EHgF4Et8IeB3yl/78YEloZhGIbx2HLHkREi8jPkXyOuA78pIv8EyhhaQFW/6uFmzzAMwzCM1zOq+j4AEfkG4Mu1xCQUkR8meyOMR8Y8bfPOaSrHoQuPl+8H5XI4wKvWLc9zO+7l/PcTnvKqfBznYV0GUqZKCh1991RLFdMBJ11b3vjrTHoo+3iSjnlir9bpZTtUJ+pXfCWR0vkqlKe08895EumQch4nAScbgt+WYw7EtCPphJZzo+m2oSzvj9vds8qifDgOk1nz7kt+jqfx1vwlBI+IRyRPk952b+TEP8Wpm8v6ufH32jVNcQ/AafdpPOHz77Fvi2/nTeFz6crcxt8cP07ne5LPZf+ie5bnpt9jNz5X7sF8aXW63VxuqWwuZe76FkJUcKhOLS+Cb9No83WV6cjurB0n6YTgcvhXQHVCxKGa8C5PRY5ph5KQ5dRS16+m/tU03m3LcVI51vxPRiddy1sNI9uud8Wyfbs5vCy0kLS13oo4nGxIpX6pJpIe2rTYpHsut9Pb1ZvjcLAvd2D/Vf3M3dLA1f3OcQjX5QTPV2ICgpAn+wreP7E6b61fmnaX2kqb8tvuc1qFEa7p79QOH6wfv/s0jZ8G3gz8b0fr/xjw4Qc6o2EYhmEYxv3zmeQfR54ry9fKOsMwDMMwHkPu9jDiTwHfpaq/ulwpIufAdwM/9rAytjofyo0iINyEkdP+gHMJV6Rl282e7cmezY1zAJxPpOjQWMSAuxNu7k7Yjz1DnOWBQ/SkIjPzkgWKVeTmXUI1y8+qxCwlR+cjXZFp9t2E9/OTwJgEJ8rZ5sDJNj9R7Uu+D/sirLw45Xx/wouH/MTxfOyLvNKxLw9woyojqUnvIp4xQV9dfJrFdFGVqWg8EopbCAc7N/9VuVuVRs4iOs3CuiJrc0VeeeXvB0UeiEuISBNP9ihRBXFXPyMD6F2WPVYR3fJ9V8o750BJvsobhd450sLA54rgsor8Qt23Ch+jZ5p8E0+GMCGihDC1ml7ldfX8/WYgdCPBR2K5Ru8S3kc22yK97EbCZsAvBZZO0SQ4H8s6j/MRH+ZfCSREpn0/LxcxYz1PTMKUXJODTkcS0HofBGniRYfLT48Xy7djuU0uSRYv75euuIM1lROKWFNX8kMR6EpZnnYjJ93AttT57WbA+4kYAyL1yXeuC+PYteWuCGkBgkZUhUl8kyCqCon5PufryWJUAK9XCCwBNKyuaS0CzYJIdBZUQhZPVvlkJw4ly1XLAQilROqxAo5u0Y0mNB+b5XNvKeukHXfZVhNZtOmZ8yJlf6kC0UXfBLn9N9nlUlDrZmmllF8sV3LFIsWUxXnqH7CSX+bjKUK+x5vST2x9ZOsnNqXv23bD6h4OMeBKXfdln95HDlPgUOStF1NoQlLIosvOJXpgV+pG7yMxBoYiIhYfIQlJpbVj77L00rt6jQqyLquoQlQh1HamrtUpyH1/75RTP+c1+ETUua3uo2fULE6FWSJcpZQTSpK5nPM9EmKCKdV8rLe7Uk868Uj9RROlI7DRbbkPWaoqpX4nF9uvoHMbfl2pnL4X+GUReX9Z/mPAX3p02TEMwzAM4+Vwt4cR7zh+EAGgqh8UkXc8lBwZhmEYhmEcoap/Q0R+Dvgj5Kcw36GqH3vE2TIMwzAM4wG528OI7R22ndxhm2EYhmEYxivNFwL/SnmvwM88wrwYhmEYhvEyuJvR5/8UkX/neKWIfCPZbG0YhmEYhvHQEZHvBb4V+M3y9y0i8lceba4MwzAMw3hQ7jYy4tuAnxSRr2V++PAeoAf+9MPM2BIBfJlz3oeJvh8IPrY5yidnF/TbA91pnqueRk/cbdid58Ebu8OWi2HDEH2baxyTY0yOWJfLvOJU5vf20bOXq4y9SnDFE+AnujC1OfLXy1zpTcgOAoA4efa7LecXpwC8tDvl5mHLc8UZcYie88lzPs3OiENKTMQ23z2pElUXeVXSwhtR0xxT01SyA4Pme+ik+nTdfG2iKzd28zHU15Tna9flIQqjQkx5bvySOtdey0T0WvYJFt7emnZ2WsDi9eiYqVwDwFScHtUDcpg6vEt03diux/vEOCquzF2veXB+YYhNs8OiXrMkR4q5XCYJeY75VMy/yTV/RCrn1iRI0Hb8vKNnGvL89+HQc9hv2O1zXQS4iIF9FIZYy7jWQ1o5TZrn/KdS/y+9kuh19lLUdctXKDbtsuxITEx0bfvEhK6suU48SbV4IrJ5oNY3V/NX8lrn/g/R03u3LgPAuTjf+5S9Hrt9NXRnr8AU5xqhCPux43zM13Vr6Lk1dpxP1TeQ28qhtJdJlUNaG70HIgNTqz+1LY1S7psqXXIoyriwgU8Sca3Or/0QCWUi27rnsvWXvBSKEkmtPczpqxFaSShJ5nJKmp0vSxLgjtp1OmrmQWbPQ94us2sDZbl787YfnUdZWwfich8VOpddMnUvR/bLVE+D9yn3HaXP24SRmBwn3Wxud6IM0bOvzp7kWj8EZH9GcnhRzjW3GT8kzg4bNhe5H0/JIaKMQ8/+kNtQ7dOr12fupyivwiE5+mXfX/r61heQPTp9yX8QxVHyW9r8rbFjNzl2pa3eHGE3KbemvM8Fe0aG4v8o5ZiEW5OwLwU66rJF5vo0KkyaiLV+MjEyEcn1NDIxyqGZ85NOxGJYn6T6iu5kof+U4yuAd2vRr4vI+4BfBr7zkebKMAzDMIwH4o4PI1T148CXiMiXA/9iWf0/qur/8tBzZhiGYRiGseZJ5mgaT9wpoWEYhmEYr23uNjICAFV9P/D+uyY0DMMwDMN4OPwV5mgaAvxRbFTEI+Zeormsxl4dbTtefiXOf9W6l3ueeyWP/hIEZP0VW/AoEWE5EnBE6BaJcpydKe7ydp0QCcQ2Omogph0pDWX/CDqxjmeWALca7biclV2jKaEJpEYRO8PJJh8P8G6D4AiSR6GpJJIE0KnlN7Enj1+Vlvf1OfM61djSKIqIRzW2vGiJQtWOkWM/IfXcOuYyK3kVTTjX42RD0joS1pHSgNYRoBIAR0o5sp33p7x1+4fZ6JbP0jcD8IYu8DvDCzzLJwAYdMfW3yCWY3rpEBzX/adzLeXnnjflgsM08jH/NAAvpg/TuVOmch5Rz258BtWE6hxtb762/CoKyHzfVUdiOp/vk9SIY93qEKrjYimRdFiVeWJcxFlKqCbQREy5PiU95HpYB9RpIsZ1PpV8jpiOzlnqYB5327V0y9hhLS/HEc405fZQy0QcSWscvXp8SAxoO08dbVrPk9raZW7vzCsVbepBjlPqa6v7tQ9S1tfySvdN+fiK46zPdf3W4cPEdGtx3ppOFku53aF3yo/j9rETH5x7ehhhGIZhGIbxKFHVvy0iHwD+ZfK3qG+3aBqGYRiG8fhyN4GlYRiGYRjGI0dE/jRwoao/rao/BexF5Ksfdb4MwzAMw3gwHo+REQLbPg9JO93uODu9wIeIL8Kx/nRP6EekLOuhY9xt2RdJ3jAFYhUvFtnemBzDQmDpAEQvPZ1JqyEsQlRHVbl5lwhhHt50WmRnfT80IWKMgf1hy3kRVt4aNlxMHYcqXUyOQxKGJAzFTnehEzs54Epu9FhQqFlGqazFlU6EUOR0XgQvEBYXJFL2ayLJLCD0dchNkbp1LjVxZRns1/ap8soquYsqJKWJDnM55Z+sqoRy0vy+ZqUeT0TbgKFU5I1TqsdVtIj+luhCwFnvX9RZoNhNocntVB3ORcLkm8BynLJktCtDxeLkGYaew9A3iaJ3WchXr7krskrv8+smOnw/4nxCS17SFJiYxZiqgiYhFoHlfrfl1vkZNw8nvFjq5YtDz/nkOSxke1kwWpeV2NSTR0Mf70IVXLZl0iy9PB5GyWVR6KQpS/6aRLWkE5mHnC3qAOTyn5JnKu0gpQHnSrsbczmMU2AcO26V9qAqBB8Zyz613ezGjvOyz0tjx4tj4Nboy7JwPilDqqJOmgBwHiyYt0WWwxfncqyiybRIm9NPpNItroaOLhAEX4bZejxhkWa6lLqU26JncSKXJJI5jWSRY8E3wWxuP17m3NT25F2WWM77sBDdgve0EYCxjoJl3sdLXpa2f5bYLq+nE2WzEDxu/cTGT5x0uU/uwohzib700dspC1910TYh9zdLiW1a5MOJ0rmEd4t7kRyHsWMo9SCLMhPjGDhMRQxbpJhLcaVblUE+51IsKaL48lfLcuMSm3JuL8qYHGPyXMRcF6ost7bNISmHpAxlOONBDkwyoaqtLcVyDw6l8URNq88Xd2XtgiTa5JSzjDafJ5Xz6RVt+HXCd6vqT9YFVX1BRL4b+B8eYZ4MwzAMw3hAbGSEYRiGYRiPA1d9Z3k8flQxDMMwDOMS9jDCMAzDMIzHgQ+KyA+KyLtE5LNF5K8yhx03DMMwDOMxwx5GGIZhGIbxOPDvAwPw3wM/AeyBb36kOTIMwzAM44Gx4Y2GYRiGYbzmUdVz4DsedT5eX1xlNjkO7dZsNkfr0xXrrw43ySUv0iJc4Or9Vfvdy+9qx/sul293jOM0V3FcFnFeq8chE6/eQxmOEl1V5nOC7DK7W3i924dQVaSE73NQwjbGOBFl10JJqqYcLrNcg5NAcCcEd9KOM5VwkTVUqRJRTbjjcJTEVZjLZUjOvNy1sIeCJ5XQjiLVP+UI/my1T/XmiLi2LCUs6rw9hwDN13fBh87/EUrk/ynHkJ1fnecqVCduHn6Pzj/Z1ok4XPEJ9f4a+/ginTsFcjjQa/1bOcSXiCX86jKPtTxqmNd6zbXsVmllrpdOOpKOiNuuykDEXQohWs/jJOQ0rm9pgr9OSkM7Tw7BeVz/e5Z1XnHlPHMbyMtzueVa6VDm0J352sqryyFbaz5kEfqzHqda5ERKHdMEjC0M7Guf4zaZjtbeT0jSl0PtPxIv7n7zDml8M1fVMLqrFBLafZ3X1dC7Mzn8cF43xRceKMePxcMIQemLPPBku+f02jmui/gij+xO96v0cegYDj3jVOP0Kn2I+KScLAR5IhCL7HAfXRbylXsYi6iR6JvorOZl8LnYYnJNyFbPoyqk5JpQbbcPnB+23Crn2RV5ZRU+xiREFQ5ROBQr5IGRg+yb9O6gPYfU0ZXto2oRo6UmUEtwZd1OupBwlu1VChnLh55PC/mkAOnoQ1nWB06LxUQWGcbFOiWL8ep5o+oqqm4lMIswkxYx5+Ick2oTdFaZ4LRIk2WPjkPJ76HIKasEcUoe7xJOZjFeLGn7qQjikjBMHTE5xjjH/vYuNaFlP02kJE2YOo4d/WbIolJXBI/RESffBJYpOpIKwz7f94vdCbcOW24NG14c84fjzclxa5J2PWOq152Xh6SMmhhlbJ10VVrq4ovFUszocC3tUsx4JwFm7WgSuWu6HeuIxJm4kMLuY6CfImP5kB7GjljKsEpFL4YN4xTY1baJ4mNgKOmcKIJyMfbcKuLCm2PgpdFzMeWzn0+5bGKpG1JEj0sdoMeT0NVVu1I6eXvWBzp0JZeUo042iyaLdFETAVeiN+d1AaGTud5Q4qnnY1eRoeIXZ/FFVDnHAq9i0LmLr9fkmpB2/sv5miWxVVIr5A79cPS57RffvbOwUpDFceofQBBl67W18R6l94lTHzkr/e0T2z3XtztOt/mL6Nm183ye0j5iDKTkUYShiEl3Y89uCpzX5ckxqdC5WvvnMqzt9yBZiFrlp84lnCj7w4Z9aUP7KTAkx1AlnVW0ekVnWPtxLwphapJLAbY+chZqvHrFO2VMs7jXlfX1fsjRPwZc+c/LomyrF/goH1drK2ecyqqhORye7op09cvew/xS89pCRH4f8BeAd7D4/qKq731UeTIMwzAM48F5LB5GGIZhGIbxuucngB8GfpTLP/0ahmEYhvGYYQ8jDMMwDMN4HJhU9a8/6kwYhmEYhvHKYAJLwzAMwzAeB35GRP68iLxFRN5Q/x51pgzDMAzDeDBsZIRhGIZhGI8DX19e/+PFOgU++xHkxTAMwzCMl8lj8jBCcEVA2PUjYTvgQ8Rvs3HXb0Z0IWGcho5pDKTFOi+JECJTKlJCP7GPgZMiXdtHT0rShHdjEnz0TDJL8KYqP4yzqG0cU5MiTtGjKm057+PZjz1DqtJLIS2kl1UAeUxkQsvAlZHImBKTy8tVXnlIOVWlE7cSPlbZWpXRVUldXU4qCNpEbjk/usqfk5zHKlUcVRgW5RoVJl0r1NLR9SQVgugs0lukiaVwJ80yyyqg0yKqjCtJnKKL/CXN96vmf0wOHz2+mJGn5PGScC7RVblecohoqwdAk+xV8WJSwbvU5HWqQlSHn4pEUh0pOTRJE1aqCpqkCS1rfazixmHqSMkxRdfym0q5xaPyah5cLfdjIahMJKKOK8GdyGxlTs1ovBZWJkmLNK6tA3CaGJnw+EuO8rSQ8E2aa2TN7nzPqqhUGKJv5ekOG5zk+3Uowsrzw4YhhlkeKOCSrsrEia7EpPskjGlRB5MyJmUqdT1QXdBzQUZi0Xzma3Y4JonEYnqOeMYrRJ+5ReW8TihoasLBVNShS4FlXe9amlxaeukOzCigqiSZ90ma22vdx9dj1fbc6mJJsGjL9R5VueVS8ApzG0uaJbD+yJ94rFP0ooRSj4MowSWudSM3+iwKvrG94Ma1W2xK/7vZ7olTWPV7AMFFhvIRM0TPmBxjaRejCnHVPy9808t2l+b+NCVHVMdh6tiXOraPgX2UJgyOmq+nCYJV2znrOTZ+onPSziOibH3kWl8+T5y2vA3l3J0LdE5XAtEltY1G1bYtp5VWT6dWT2qjSgSp8tj5+pPMtWeSaVU/nXicuEt97OsFVX3no86DYRiGYRivHI/JwwjDMAzDMF6PiMhfVNX/srz/M6r6E4tt/4Wqftejy92nOvfy5Ks9Ar3N9vtdf7zt9mEq736cu50z3mb9gxx/GWVnHe5UEBCH0LWwhwDo/EOB4Ns2X0I4Ch7n5q/qXjaM8bwtJx0J/gTBtVCST24+i0O6hS8hNjs5YSvX2OstAF4cn8ZJ4Fr49BZBKjKimnijvA2AG+kJAG66m/mV57gVP8Fueo6UhsX5dyxnfDvZMOnQrg1xOAktTQ1RWUM8OteTdGQTcujMw/QCT24/G09HZA7l2XPKKTdyGtmhJC7S8237Rq7xefp5fM61HGnpRqechcS735DTvONNH+fpZz+NqI6nb10H4GP7nl0Unj3ke/WR3ZQjmJUQljsGLuSCg+x5Xj8CwKQHDvGlFspwiLdIOrV7Uq9rGaYzxQGRsAghmkg6tIfOtXxq2cxlOxHcWT5e/TGplH0Lg6nrsIvL8JtJJwRHSvtViFOW6TSVEI4l5CaOpIdVXUTT6kdTJSLq0XZ/3Jyndv4SyrM+TE+5LrTti2Mfo+ufN1dbHi8eVX7vtc+ef+5dh4etv2zd7ThXhRh+MK+0OSMMwzAMw3gt828u3n/n0bY/cbedReTtIvJ+EfktEfkNEfnWsv4NIvLzIvI75fWpVzLThmEYhmHcGXsYYRiGYRjGaxm5zfurlq9iAv4jVf1c4IuAbxaRzwO+A/gHqvo5wD8oy4ZhGIZhvEo8tGkaIrIF/iGwKef5u6r63SLyTuDHgTcAvwR8naoOtz8SgOLLnP+uH/H17yTv5jcD8dCTDnlIWhw6xrFjLPOKD1NHTC7PP9Y6tMqX5Xk+cSfzgKA673dSQWL2CzjgEAObKQ9nGcaASGIc83n3Y9/mvPviuBimwBA9U6y+B1c8Effy/amUJUIQaXkSBS9CEIcuhtF4BF/mofdO6BwEgY3Xco15fvmmzAffuIQI9H4xJ5k8h3qZPxFlXHzf8zKP3vGS55XrYrscvda51mFxyUnKkzBXr0lxmt0AAN7la/Qrf0W+vnlOtpaBYGuqU0IURPIgxDbvXPPy8vp04SvIy0fbb/NdV5yu5p0rsnKXpORWx05XHEeY5/p7yXPe66g1L4JD8ARcuUpPh0pqQysdDqfrUnC4S76CoIHp6PRuMbwvofjFNmFd1knzGZYeg0qdi+8AJ7oo63lu+1TaUC0HqXPvyxCv2y3XMnKyGPQqtf7PzgXX0q4vspabIDgVkrhL6dyi7DxhtU2Q5l5B13P72/Yr76scDTVcnzMBTpfldpzveq2X/S2rdHL5fa1PsZynla1kR4mTOa0r7bemEYHOJfrq6HGJjY982uk51zc7AJ64fpOza+eELg/R9P2EqmMq/a1IQiQRAgvPyuUy8k4J1ePglN4ltj62awwu0ftIKH1/8JGYFCf5r5WrzNcchNLvLcs2L3cuH6f3ES8J7+ZjnISRJ04uSpmk7Dg5wK4Mq82fD0pf9tl6YUzCtriATtMpIxO9d2xL2Y0CGw+bUthdXPdUnbhSh91qpGOngY48pHZiQsW1gY9Oahm/7n5H0Nu8v2r58s6qHwU+Wt7fFJHfAt4K/Cngy0qy9wEfAL79ZebVMAzDMIx75GF+ozkA71XVLwDeDfwJEfki4PuAv1p+iXge+MaHmAfDMAzDMB5vvkBEXhKRm8Dnl/d1+Q/ez4FE5B3AHwL+D+DN5UFFfWDx6bfZ55tE5IMi8sGXcxGGYRiGYax5aA8jNHOrLHblT4H3An+3rH8f8NUPKw+GYRiGYTzeqKpX1Ruqel1VQ3lfl7t7PY6IXAP+HvBtqvrSfZz/R1T1Par6ngfJv2EYhmEYV/NQx3qKiBeRXwE+Afw88P8BL+is7XyaPFTyqn3bLxEvTYeHmU3DMAzDMD6FEZGO/CDib6nq3y+rPy4ibynb30L+rmIYhmEYxqvEQw3tqaoReLeIPAn8JPC5VyW7zb4/AvwIwLtO3/i4xXMxDMMwDOM1gIgI8GPAb6nqDy42/TTw9cD3ltefekg54PELS3c3rnIpHV/jMs0lu9MV65cGoOP3XLGsXF22x3lzl3xCc47rvpdDDF6V+jLLEJ4Jin1JxCN0dCGHyEw60vsbRD3M7hc8h+m5RchH8G6D4Oj9tXxGjSiJKeUf5cZ4jnd9C+Mp4pjiDkh4dwLAC4cP4Vxg63O4zF16nskdWpjFf8n/6/zB66f89s09bz/JIUTfeS3xZZ/5keb3+d0XO377pRN+5YV8zF+Xj9O5UzTMzqpDvElMAe82AAR3wlPd29u17PUmPaccdA4zeoM38bx+hCHlgdNPhLdykZ5vZXISnuSz0u/nhA03JXt83qjX+Zh7lpF8zRfpeU7dU3Ry0q7pjCf5f90/5Rde+O1StjnU6fShm+XOjfkerUIYXubY9bSuh3OI1nmHBBKQcn1OAinlUJ4x7co96lASmvZlOcwhL8khOJ30TOm8lW39zXZK5+08OTxo2Z5KCFFSqz8pDSV87CIkp+RQnC0v+FU4TSWiGvN6IHFA6HL4zhayM2/XRajVXM/reSZENrnkZNlGF22qrr8ipOfVZT5vNR4cKf/Mz2WcuHtfeS/bjvtsrjju/fFQH0ZUVPUFEfkA2WL9pIiEMjribcBH7uUYrkjBnIs4n/CbEb8pnXE34SZPIncGWaCmSJGYBRdxKL1XTvq8T0yOw9jxzC7H8I0qJUbvQmjpUhNSAk2ctpSnqbqVHFFVFh9HWWwozELLoImospD+Cd4pnVO6cn8Djo6+CQZP6DnxnrNigBwSjEnoRBgWwkQvwlnI+5wFOA1ZHLktgsread7PzdK44BKbkjcpQkgRbWJPVWnlmPObz9MElpoFbH4hNUyaHYclK01gWc+blJUYEWBKUuSAVfQpbNxSyphllL0Ttr5K5LLgblsEd9swsfETXbleLwnnEr781etJKm15+d7rnCa4hTiviO+6IuwLPtL3A32/9q5Oiy8UtR4tjxFcZBMmtjGUexTZR1k14ZigdgCdg414eu1Q8hcGT2Ak4BdNN+i6GS+FlwCJRGTClQ/y+gFTj+Fw5YhCL0XWKsLG5fLO1wOjZsFmlQV2LtepKjsMLhFcWtWXrHFcShizSDC1dpZwom15Sa2XG6dMTqn+v5OSAdeksBC1fAGs5agBRyKVjtLjiTh8SbehY1OutY7yTiSSJkIpn4DQybIOZlllQlv5BnF0Ikyl/vuSg/y1tAo2dSWp9EWqKgs5pVdpgta5rKSVtRSBZ+0j0hX9/rHo07sscU0y92nxaD8vuZ0upbBelL62KR856waeOr3F9Wv5S9G1GzfpTva4hfg2DmElqXQureS6WVqqTRopMUslQ1nuiqyynheyaLILU2t33kecS/Rh5CSMJX8TW981sWTyQhDF17609HG9m4992g14lzhlbr9nmz1np/mLr6oQ9lticpzEXDe2U2RIjtPS90TN8uN9qYOb1BHUcRqkCYElCb3zdKX8O3E4aV8TV/d6/vIISmBcCCxRSFI+/9S3tHXd7QS7xoovBb4O+LUyWhPgu8gPIf6OiHwj8CHgzzyi/BmGYRjG65KHGU3jTcBYHkScAP8aWV75fuBryBE1HuIvEYZhGIZhvN5R1X/E7X/m+VdfzbwYhmEYhjHzMEdGvAV4n4jUsTx/R1V/VkR+E/hxEfnLwC+Th04ahmEYhmEYhmEYhvE64aE9jFDVXyWHzzpe/7vAFz6s8xqGYRiGYRiGYRiG8drmoUbTMAzDMAzDMAzDMAzDOOZVEVi+XJaXa+/6AAAgAElEQVQTPVUdaQxoErSIIxkDaQwMN08BmMYsHavywM5HoijbbhaWOZ8YpsBT22yY9ZJ4YdhwiLMIT0ThSOCYVIhahZWOlGYBYudjEyJWyWVSofMJZRazAUxN9haIKgwONsUityGw0W1LuxHPxs/yOlUBly3SurL8zmmq+M4t3ntRoghdyZsXzbK3pXCwSCzjYnmJE/DFrQtZ1Jn3n8VsSbJUsAorq7zSoe0Y0vI0HzcpjE1ol+V99ZhSxG9BLk/8rXmsx6zLVV7pRFdyvSqxXLJcrvvrFVLFuv04TZWXtuNFt1oOPtIVQV8VPnZOCYtTJFjVEidZctepJxXJYpVTdkVwl0grWaVTwR2ZwyMRpMjwoKWvr50GOhxeHGEhWfQLoaKKklK2ltd1TtZPM6uvMC2Ervm+LkSNTiElkvq2Tm4jmpdFPfVOm/DRC3QijPV+c1kKGZPiFKYmlBRmrSx0uCanHEt7FgRPwi/ScZQ11+q9W5XTnDavnzS1+s4qD7OMtQoeReS2HuJ6H53MksmapyqxlKN1x8da7iclTT1u7jPmXiT3F7OUdOsnTsLIyXbP5qT0lf2I87OodBo6prFjHHKdHMfAOHZM0XMoffF+Ck2KC1Vqq02uuyki2q2fWjqH0hWJJWSBbG1T45Q/uq6NPdenjpuh3jO3alNBlOMn7iLKJoxs+izBdC5yst3Tbw/telJynEyBschmp+gQUZL27ThjcmxLB9ZNpS0t+tfsIp9lmgBRtYlModRbkSYA1gSqSijto6dHZRaxCi5b+tU3wbFhGIZhGMbjymPxMMIwDMMwDOPx5H7Dnt1L2MyHzTJk5TFXh8GU5VdKcavwfZfX+SvS+Bbmr4YazPGY5vfLbfP2+4goU845H6vFH7oUsvE4zeUQhDCXRVy95pCcA4fxouV0nJ5hfR8v53ss5b1rDyD90XlrqMnLIfWm+Pzq2Hs+vEgzn+sf8xv8wk7zg81DDsvZ3bzO939sDh3ZuVM27loLyXnGU5xwyqmcclZ+DNn2gU6EW3EqeU+8mG5yTfMPgxsCUmJq3dL8sPfcnfO5+oe45fLD7YPueYu+nai53K5xwifdc5xz3n4w+Q35VT5D38mmRBV7m34GH9VneFt6O2Mp74McmGTiTf3vA+Bm/AQ7fQ7n8j4xjaDTlffwuP4sl+vjbCfbshzx7gQt9db5Hicd3uUyUU2ELpdp1BIJSrrFz3XlHLKIjKQjY9ohcp0gm3KehJdNC4Fa70PSGr1sQyrHr+fJ26d2XCcdU9oh4oglNGznz4hpaPmv53ft+CPebVBN7fiJ+nNj/eHGoSRcCxvp55CiNSrdpTI+au9Sw62CtH1qW16296vCUT4uPKqQzsv6e7tQtuv+fQ5Zu+xb3KqvzQmv+DzQ+Qd31f0D5dh+WjEMwzAMwzAMwzAM41XFHkYYhmEYhmEYhmEYhvGqYg8jDMMwDMMwDMMwDMN4VXlsnBFNXDYG/KHHbwakyA5xSjx0xCI1E1G8j3Rdme+UHCFEYnSEIkObpsBpf+D8kOeBbcPEZuoYYp2rlM8ZVaAI+Uagd7EJ+cbo6fzURG7BRYYYiMmhR4LDqqgTASdKVwRxk0t4cUWKWGRo4pvArOzcZHWVmPK6qYjPsnhOmkQwakkjILFKFh1TkibSy/kRfM1jEXZGIKb1c6pZ1Eg7X95JceXqqghTKDONbjONM+XJYuU484Upa9ne7ah7RBVick14F5OgbhZJVpGiHkk4U9lvubyUTbp2r9Ziz1mUWQR1i2NocqTocP7qubTeR4KLdOUP5vL6/9l7txDbtvQw7/vHGHPOtapq731ufdMl3fIVO4mdGOfBCQiDITggsPNg4wQSBQwK5CmQBwu/5FVPgUCeBDGWwCQ2OMEmDwmOSIgCiRLdHFmWrEgdqVvqy+nuc9l7V9Vac44x/jyMy5xrVe1zdh/1LvVW/9+hutaaa84xx31Vzz3G9/cdp1rqptXxWteuSxWdKlkCrpWxCUC79G8js+z7XB3Kcia6dP2aUIWXDul90ElpvyYDjNp2Cd5tIHcmEG3npOzWXbR6f32rCDELS67lY63bFwlE7+sjW3llK3ti3eObN6/PyWfHU821I5A2n23Pe9FTXAESiqK9XTN6MuaALq9srzPKtpu2l2sVCGnz+TGt+yunOlVo8ZSy5JZuvf/mdxEobtI/y1fLc+ujo484lxnHmXEsAmDnE5qFXNs0zYGUPMtS5t/jPHI7T8wxcL2UfbRzdszJk2qHVS33bmNXN3NQl2vK3XHofMbn3KWWY5XCNllukeOeCmudlH7bjjlRhhAZq9B4HGfCsO6rTCkQ6/dAqPUwhchFdhyrKPOQ3Z35rbV5K1ORrpZ5GGCpe9C91O8pys5YgS619CJElV4HnoDguqzS4fEyoJJOxrNhGIZhGMbriP01YxiGYRiGYRiGYRjGg2IPIwzDMAzDMAzDMAzDeFDsYYRhGIZhGIZhGIZhGA/Ka+eMSDGQF086jmjdsy8uk44jObl+rojiq5dhmo6E6pDYX5bYxjF64jwg778JwHLj8ZK7y2HOjqzSIzo3tnuP9cw1kNSRsit76Df7ndu+Y6DHYm3eieQyo8+MyTHUGw0i+M0e+3aHvvcbWFRZsrLkGnNYBCfS93wvuexDFuVkb3NSYWx7+rV6F9p+7ZOy3L+XnFofuZbPqSBSnBi+7tv2Na+uuxXqfndZvRNJhcEpS3dqrHUCde/3xmFwngco+87P85myI9c2bOXOKj0v5Trpe8Lb/vJtW0q9vve57Ah+bcPtZw1xGb8ZTT4kUvSEUK6LyXfvhDtzUXT/A82ZsLZPViWTN+6DTCL2TpGIQFhj/9Z4zX4TGzjX/xpO3cfuN896Gpe85a98dvp7rROI2XWXRhsL23bNKijSvRLS676VR5DT23ZHxJ3f7YSX8ozoaR00Nwbc8Tnc591YX5ea9eLW6zfjDi1+iFwjcbfrvKwpicjZnAJodaZszxFhdKtLYDuOnZT+oaz1m5U+h5Q0ynlx03VLOuWnvD+dH4KsHgaA3bCwGxbCEPFj8So4nxFRUqx+HT31e8TkOS4Dt3HgWD0+5w4akbvj+dzd4iXjJOPqvNIcQTlvznEZL9r9K/7MM1EcLGWOaz6gOQWcU1wd58M040SZj8VvcTiOHOexpw9rnUy1XkbnGZzr9RjEsWjGQf8OyVrazNeilz63tn0QYefXsd6uSeIIzcehQiD0Pj7LgNTPPM098brGYDdezHdDm3Y707dxRdy+eXGSAAho5EUTuL7g9Ue/f4l6O/vuPrlC072fvHxrbHxceBBH8E8AeDR+H04Cn9EvsEjx1bzHV4j5yJLL36WD2wOQ9MjkHwPFE3PF2zzlXQC+kP8U77lv8XZ+ByjOp+8bLhkcPF1K/j+7D/yJR5FjnSsnp1yGxJ98872ev1/65jtc+MxXb8tc93PvLfxf+X/lZi73udWv9TKU8rhuQmqzmJJRXc5qwPe/c9dZ3pW0AMShekRrXQtS/EfS5Ee53FPXv3sE4Rvyy5u7OESGs3tnnOxP8ujcSNa5vh9QWRBdv3mad2n791PPRyuPtvn80I/FdKR9W6d8vyes5fO0Hj4Otzn31cwBS/zGx54TX37Ir3xMdvUlznnJU14j/qBK8zL3PZ3fX9Q+dw59bNKfpPPYygjDMAzDMAzDMAzDMB4YexhhGIZhGIZhGIZhGMaDYg8jDMMwDMMwDMMwDMN4UOxhhGEYhmEYhmEYhmEYD8prIbAUocvGfIiIP5XBpKWKvJrELCR8SIwUcU3OHpHMtDuyzEM5xydydlxd3JRz1HGzDCwbcaQXxWXXpWijT0wuMfoiaboYj+x3B5ZY0jzGgZwdupFntt+yFVrmjJcmnixavaTCo1DufRk8N/NArKaQwTkmJ0zVq+MEliomchvZzuiEsWY/OBid4qRI6Uo6yoAy9PJkJpcZ3VqfXTfUZI7t3FbX2Z1II9vrRaWn265pNXmDwwn98yzFUVTeN5FgE9DV/Espr7LK+bwIoy/lKuXVIpbbSOYGV34Agk8En1apaM1bk1Zu86oquCoqcrX9WtsNIRJC7BLLECI+pC6nbOhGZKQqiMtIrG2YHDEGwlYO6BM7H0i61vGcHEsVxHgpbT+k0KWKkURmlV4iMOqAP5MuOlw/FvA4dV08I7VOxzr8BxwXPhA2kkQvwkWQ3nd8FSy2dij1D6NX9qGMh8FlgstMoUilxhDxkknq8LVulio0bP3fOyXlU6FY8Jk5epaN9DBrOFFJln6zij+TNsnWKqb0KpBXoZpspJ4754sodiufrIl5VinhzrmTz4RSD+14k0GGjRAzA4MKsbarE2HYWDlH5wgbgWNp/5K3dt7gSltchlU0ufOrvBPKHKBn0kov4DfzhLCOKUXICpMT6lTDzisXflV77nziMixcjUcAHu9v2E1HLh4/Z3r8nBPqXApVClvn4SUOhCXhkyfUuXrMqQha63x1rG27Oxu7bW6FKs+cjkz7Kncb1s/mpdw7uMTgMtNmTtj6lQYpc8Qg63j2khmHmWlXyjjujpCF42E6Kc8W73K9T0njwmceDZlnSynPbnHk7Ou8u875lyFwGco5V7H04cGtfWVyQtzIfrM6kiqD1rokFVFlnxMCXgbU7Ri1zsovIXA1DMMwDMP4bsRWRhiGYRiGYRiGYRiG8aC8FisjDMMwDMMwXg+2y1XaCsBvN8zbNg1XQyDeFzZtsypMXA+Z+NEhAs+X03wn8nZfGvnknHLp5t/A9G7Iw204x/ZePm75j9Q/ZTXeuf7+c+8EK0dk2oSKzJyGWaTWa95cUxjCW/XzyOAfIbV8PxD+Vf7jz36Oy7py8Nef7vm9G+XXl2/wHl8BYMm3xHzkMrwNwB/NfwqH451hx00q7fjWEPj6fOTffPuHAPhwEf7Cp4R39mVV76PdLV99OnM1zjzalVVkP/+17+M3n018UBYH861j5Mv6IV/5vf+v1mlmkq/zwfJlYg0rmtJNLcdxLbNkvFwC4N2eyT9CxBNzOSfpkTl+iJOySkvEMfhLlnRdajHP7IZ3SHrs4UCzRlIOpHrfsmJxwbtHvR6dG0/y1PqMa+1c2yZr7mNCZGIIj9AW3tyNPR+lzMvapj1cKbUP1vYUTkKKvrj/blcFLnf62t0+/KJ/992kLy1UdstKG+9u817vufY+tiFF3cecy9k5jrvhGV80/vSez+87dt819yEvcY7x7dFWBH9cyM2XWWK5rmY/Pfb7x1ZGGIZhGIZhGIZhGIbxoNjDCMMwDMMwDMMwDMMwHpTXZptGF3wljyZHTg6qRE6TR7MgbpUR5uSY57LUa6niwKfPHhFTXQqFkFVIVaR2WMq57enMVtLYJIcAUR1Zm1SxpDFXcdvNPHG7DASXugDNuXxHhlbSdz29pELKQmwyyJwpiw21nnu6DCZ3mdnp0s/zJ0tJhaT0evFVFLg0KWEWFlZBZytr2ogDHZx8rqIsKgRpeVvLlteTamJN4FcElX3RqJ6dD0SVml+p6ULKsOTzskuvz0xp6/UaVwSEtbxO17pvbebgRGipKiftu62H4FZhZfCJcSxrHn1IDMOCc+uyJ1UHjn5M1eFUSHGVq3qfGHzq8sZBtIg7ZS1z1PK7vVdVMkqsS6xyE33WpVf5bIlU3iwvbEsEpf63XeKnmzQFqfdZ5ZSO0s9aU7ZmUC19oNYSWemiyegcQR25vk/Z3emUIooTJW+WerX22qJIq5Z6Db3PNSmjr2nHtIo1m3BzBrIqfrMkOOvpWNnKXbc4afW2vt6S0T4mXW+7dax6kbK48kxqua0KEWjFdiIkuT9/L0Lq50m380E5tn2//b1t54YXLT+bY+fzVZe8trlThbwEYhVYai7z7VKlkimVki7ZdznpnDwxu95XDqkoWVud+OQZJDO40CWWWse61mvKayFF3+f2wzJwGwPH3NpB6rhpZcgckmdyGanDNWbPEgNTzWeOgWUeeH59BcDTmwuOccBLZq5lXrJnTr7PNZk6F9W7JFWyKmkzHpwoSdcFvE1ymtfh09uii1el9J9tX3G4kwWWgiNrshWthmEYhmG89tjKCMMwDMMwDMMwDMMwHhR7GGEYhmEYhmEYhmEYxoNiDyMMwzAMwzAMwzAMw3hQXhtnhGEYhmEYxncnL5K8fJKwnpxdkz4ihbSe/VK3uS+f94Xm+yi2Id5yDV14X/jAc2mQOwnnufUY3RcetIf1bO4fXcMyru/DyfktrfV4MfbIiRnHb65JiEz1uuYUA5Ghh6NUMlt9kJMREYd3E388/AUA/oh/hz/3lvJn3vqgvP/U1/g/v/QO7x5K2n/06sgPXcG/O01k/jQAn7t8xjtPPujp/spXMr97veP3bh3v3pYbfnF+xhuy5+998Bs9jz/94RdZamjMnCNK6iEt1zwO5BqqVMSVkJm1nEriqUagHO91ocfTsJaqpPQMgJRvmeN73A2LugkimxdSutmEoM3czF8+OVfwNcxmq39AMynXMJwayXkNydmv1Uza9IM7baYL8/J+T1sYaqjbTahSXWq5Wv5qP9atlef832hL3+49c1NfJ2W4h5cf9WkTkvf82nT2/uXSu//1y5y/bd+PEhN93JzxMiGFP+ncaLw8L9P+cNoOH9Xur6a9XpOHEYpzZYA4v6nYjWhRnBLGMgnF40jObpVVqiNlZRxnnuwOAMzzSEyeb374BgDXy3gibhRRRJSxCvegyN7c5j1Q7pPLfebkWbJDNoK++5aeqK4Sx/tkjuU6oXWIQYTgYKyJZYXJCRmYN9UhskrvfJXbDaJd0idnwrt2zyZ39C7jRVHRfqzVxVZqFzbl97WePKvoUlVOhH07d1q6BSn1Wu/Zrlk28kYvgnfg8ioT9CIMDkI1/w1OT/KmZyFwvctdQqmbD7IKgz8doPlM2jf6yDSVL7FpXBjGmWlX3otP+JBwPp3US04eX2OK5+RLmarkbxjWL99DFf3tQ2Qf1njVc3LMsrbz6ITZOSb1pPpF5RCCjl1gGdTVPwVP8+9wJ8cCjlhbPJGIkhh1qOcmMsO9f6Ju/aG5Cjbv8X2WdLrUtAr8skNVCD71z8YQCZr6WFMVvMsnY09V8JIJVfQ5uQzDgtQ/Lovo1XWZ4DGtfaMJOH0WggiDtPsocfNnlhep40r6NarKII6pxSAX6dLB0h6OpIrqVjy4iiTbNV4EJ9KFlO31UAdnEBic9LodHBBh0TLWocg5h829twLPlqYoBLeO+eDW/EAZ+xnpAzEInP8Z5SjjqNHHc5tv6xhL0bPc1j9ksyPNoctZAZZlYKnvlxR6O245H2Ntjl3fn+bNu9zn/XLfIhxWXefc62XkkDyHKqOcu8iyppmFOTkWv4p65+Q5ziP7Op5vr/ccjxPvPy8Cy2fHHRlhdLHfZ8mOzCoZ1iYH7vUmTM53Wei2PodN/RfxZftsPd7L6IqEc6z33enIURdyHQuCx+Hxm/+jZBiGYRiG8bpif80YhmEYhmEYhmEYhvGg2MMIwzAMwzAMwzAMwzAeFHsYYRiGYRiGYRiGYRjGg/JaOCNUhZzvPjc53a/v0HpOjJ55HlmWdT9+zsLjR8/6+2FYWGJgqHv893nhWZrWz6sbQkT7XuPJJfbDwlSvCT6d7GmGsl8+ZiWmNb/uHuFHS3NwmUGUySmTL8d2Xtgl35VVZQ/6ms7ghOzLvui2Nzrr6fu+Z3ojiCmfr5Ko4nbQvvfeqdzJaVYhZtf3e2s91hwA7h6BgBc98Q+0Pexx48nIVVblz0wF6z5qLXv6pZVnvc/mZfdTbJF78rQtmXe5l8eJIqxtvE1j3TefCCHiWruPC2443X0vTtEsSN1/73IkzQPjNAMwMwLFMbKr/ojJRyaX+z50X/ta6zmTFw5J8Eh3RDShV1h3qwMJV68q+oGE70eox10f7IrimhgM8HhcvbYdC670udYeytqOsB6D1WXgaropt/I4cJmYfG+TwScCynw29bSxvPWttGsmn4rLZDPeYxZupbVh2XfffkMZI2lzfoIzjwOMvngmptQ8A0LOq3fCnUkMgqy79LvbQQQvkDd58SIkXevXSalXv/FBuE19einHcpYTb4II3TcwOM4EapvztvW4ee8deBRya1Pw2jwR7RxlcLlfM7rM4DJTKH3U+4ivfpW0VBdEcqQYTjwfJb/rGIrJkzc5G1zmkFZpXOtv/fPNfNvKKaIEX8YegPN57Sdb8d3WpVF/NyPM6LS2yeqnEJSsjlTn6JQct4cdt/X7Yq79NbKWwYmSdO3rxQWhhFaPIixa7tXmxOAyU71/ySfks8kqa2mnTi1K63uDOpSA1n476kiSicTSzzX9l2EYhmEYryu2MsIwDMMwDMMwDMMwjAfltVgZYRiGYRiG8d3BfWHtvhNrVM5jGrV/L+rBE+85/75jDT07pvec/9H5EBkQmXAy9ryk9Ow0xCYg7HBu7O+927PED0sp3NhDT2qN6aMk3DbcptT4T/U8kYCSaxjH0LOlZFwP21lCU7bPpebJu6lHm8kaCW5PrKEwnQSyRlI+9nPL7zXv7Tpfw0e6mm4Lpzn5x6gmnAz8Zvw5AH719lv8D9cB+d31vvALNZxky77fhL2s0XHcrofXdO5XCW5f7pVKeMvBX7Kk6162mNoK3xaJLMGd9aEfRwlXKfjejt5dAruelkhA8Az+snwugcFdEGRikB0AO73kjfzmuqISx3O54Vqe1/eBTGavF8xSVokmIg7HUUpdeh241CuOUiLdRSJfi7/G4C56G97G9xBxxNTasIQt3YYvzTqXvlP7T+ZQu/rHhTY8Hw/n53/c9ffFIbv777xyft5ZmNv7c7ausDwPe/v7YxvvruXhPM/3hfhstFC+95X9o9jeYxuT7JyPCxtqfOdodd1C726X3W5CKm/fdzZ9qM/vn6y9bGWEYRiGYRiGYRiGYRgPij2MMAzDMAzDMAzDMAzjQXlttmlshYM4RdwqJMNl2Aojm6is/p7jwOAj7773NjdzWXanKlwvI4OrcrbsOGbPTZWsxewILhehoMs9PWEVG0IREjapWhO6ZZWe3/vwTgla7psRxpzYq7D3pTkug+M2eZZqO/MiZIWl3aeKKucMS83KksvimJvqVTymIn/0Dua8CvkEWGo+ZwdjFsYmXaSI2xx0+V+rQ93cuxxfy3MdHUsWBtcEm6fLdJYsJ2lGhZhh3KzQ9FJEmrleesxFTHkuv8y6Lu5aspCdnIgNzxEpsrqt8M6JstR21o38rgsrpYjyWrqqciLJE6c4X/vEpi+43bqcLy++37+lUQpW0i+fFWFgrnkZfWbMjpvUJH1FyDg4x9BkeyiJ3MV6RQLqcV1GKQw4BtlULhBVmepwHwhkVYb6LHJyntG5LkotdVDEik3Ql1KRNopf20Q4EynWsubeVxxBUq9zKGNEzmSUKTvmjdyw9a12zuASSYVdFSkuZ+JEL6f9EdanrIc6hqJmgrgukRRKX8u6Ciub3HIrS90u0IyqBBEGiiCzn6OrODPqmm5LRynizLbSLauA137fOcMxteVta7qqG9FkF7mufaPIZDcZrOlPtSrvLKwUGF0Rbvptu7H2/dEnphC72Le1WzyOHzmnwXa+DTyfJ66Xobfhkh2LrlLRpLCo6/0nqZCykNQx10rfn91PJPelykldraNVErqlzWmTU8Y2rpsQuH4Wa59LKfD09oKnc1l63Of+zTzmRVkXW5f3O6eMtX0mJyxa5tdQ7xeqNHPosmJhydr7ShOuJl3bMWU4ZuWY6/cSSq7/AXgCgxaB5ahDrZd7GsMwDMMwDOM1wFZGGIZhGIZhGIZhGIbxoNjDCMMwDMMwDMMwDMMwHhR7GGEYhmEYhmEYhmEYxoPyypwRIvKDwE8Dn6XsZv5JVf0vReQt4O8DXwB+G/jrqvr+q8qHYRiGYRjGdwYpIRFpnpdtmLzGNiye4/7Qi1vhi9xzDFZrjX+JNM6Pydnv83tt2Yb5q2EfpThJgn/C4/EHOKSn5Qxd+JGLv8E/y18C4OvpN3qIxcFd1Ds4JrniB8MPAfBb7ldxeCa54ia/X3OZyZp6uEzfw3Ou/qCsC3v/JlGP9X3Cy0CoITeVzBVvk6uHKVLOezN/ikmnns6t3PKF4VM1v885yrF/fiu3fF7eYXCOb8Vy/ZUbmJzj07tSL9dR+ewO/tzbJazmo2Hm+994j4v9LW9+qrTR/o3M//Pz/xq/+PXPAfA/ftXxS/xTnsdvAJBqGZwELsLbQAkVqpqYcwnjGdMtc/ywhDStHJZrgn9ETB/2Y6rn4SZbH1v74XkoSUU3detAIyITzYaT8i1oPAvf59ZQoi0U5SYkpUg4Cdsq4ghu3/MvOFKecS6chEnd+zf5fPqTAHzN/x5f0a8xpxIONGvu/ail84Xx3+BLyy/1MKNZIxfhHZJG9uGNUnf5yPP590jVtyMaQQKrAupF4XFLTj+eF4UsPHU90ecEPTvr7B4nbXjfXPDRdz0d5+dhOre8aP45P/bthIc9r8v76q/Vyz1iq3vPNV4NHxcmtR3Ld884n2fuzDuN7ZzxydryVQosI/Cfqeovisgj4BdE5J8A/xHwM6r6EyLy48CPA3/r4xLbCu98SIhP+LEqxVTwQ0T82tGHmwsOxzb55Z7GG/sy6d/ME14y795cAXAdA8fkOTa5Y3KMPjNtBIWSAqrSxWa7YUZVOC7lS/smDszZsfOrJM1XGWITDqbsiNmx5CrKTOV9zK7LIWOGJWeOLV5ygin5k8nskJRDUo55le5lLbJGKLK00QlkONTLBhFEivgR4OBgSq5LCru8kHXK8FVo2d4nlZ7PUh44ZGHJq9QvSEmrSdniPX2zCDnXc1y1sB1rX59zKeNST1hyJosQ1ff8Jy1aSunC0iI7DFVKOviEd5mcXK87QU9EfE2oCPSI51kdThJLLO3qfWKe1xjkOQb8uOB8QjcyxTAuSKhi0iWciBpzcizzwMqVj9QAACAASURBVLyMHGu6KQt+I8bUWrdbyV/Ddatj+fN0qbHaI5mJ4aRuBSGjXWq5Pd7K6bZpbmjSxbwRMdbbljJWKSoUueIg2svgpMhdx1oHXjKhSifPJa+NJk4Mdeym7PAu99/tWNpIYVv95JP6Ke+PNf+xCiRjHUMJxaG06k6qzPm0josQUl8YVXzOGdxp/pMqaSPBjP3+itbXi5YxtLTPpPzxEDZtH3u9V9lhkJOv7ZJPOWmPrEVy2Zq5laWdM+dyftT1c639p905ZWHOjrV3cyLoLX3YsSwDuUpUnc/4ELvc0vlMimHt6/eILheVk6+rNh+2vB2Sx4uSEaY6fo9xIGeH1LlUfEbymRD2jFzL3/r+MQuXtHnL9TJvidFzGweOW4mqCqprWWb1LNkRN32w3avdt0h6WdPxCccqgXWU/0NwrNXrtQhhk2r/g7n124XWbxMLiUXKd51T19s7yot6qmEYhmEYxuvBK9umoapfVdVfrK+fAb8GfD/wV4Cfqqf9FPBXX1UeDMMwDMMwDMMwDMP47uNBnBEi8gXgXwd+DviMqn4VygML4NMvuObHROTnReTnn8bDQ2TTMAzDMAzDMAzDMIwH4JU/jBCRK+AfAv+pqj592etU9SdV9c+r6p9/HHavLoOGYRiGYRiGYRiGYTwor/RhhBQD0j8E/p6q/nf18NdF5HP1888B777KPBiGYRiGYRiGYRiG8d3Fq4ymIcB/Dfyaqv4Xm4/+MfCjwE/U3//o49NapWo+JPwQ8eOCn4rUS7MgYZWuOZ8QyV1M2ERrbz/5AF+Fevt55NnNJdOxrLq4jYEluy5HPObVUNt0Z+3JzaP6u+WpyylVulit3XMr4dsm0gSWIopUCeCp4G3zutrNtr5t6TrCVYLnRE6khEnr7Ta+trQR2jmFqILoNo1y79Sld3Liw81VsJg3Urwll58urJQ1LTZpeVnTKHWw5qsJ+dIm3SIHbCJQYXBCEBiq0G4rT4QiplvEE3JJeEm1fTbtIqLEtLV1C6jgRFnqcVWBAK6mk5InLgO6Ed/540gIkRjLEAohshwmXIj9Pn6ILLelfx0PEzEGYvRdYHkbB65jYK59Y8nCnFyvlzkrNylzyImlyUxrS+RNu+uJe7uJ9LT3y3JMSJtrMtqN2FBkelvpaKl7uSM/ztAlkF6K4HSsY2rykTEk9sO81i1lLLRkxlY/NOmoMvhVQhqTR0SrWJRaL46UHYuuY3NROamnQ9ITe3jUcs82HppMstVA62+trCW/p+NM6njKm/HRzm339lJKsh7PyJkYtMktXT0nnH0uUupyK+SE0o7bMbL1LsbMxhK+lqnksV5fx1OsaTSZ5XB2L9mMocHlIh6t7eRcxrmEZrkjjezi12FhzMI4FA3mfpiJ2ZNUOKYyPlwVVLZrkpbx2oS75X8DSQU/1HpyCe8Tfijz/LCbcT4zRc/uebGqB5+LjJVtG23nnNJXtoLOJrNt5YnZn0g3swoOJbjMUGWacwpd0NtYVLgKVWbshSUXAW1LS6vk8uyyLjJV4JBaRIZ2b07623acAz1qgJJxL5B4GoZhGIZhvC68ymga/xbwHwC/IiK/XI/9bcpDiH8gIn8T+BLw115hHgzDMAzDMAzDMAzD+C7jlT2MUNX/nRcH7/1Lr+q+hmEYhmEYrwZFa2jllY8Ks9o+265tvJvm/X8ufVyM+PuQs9d68l5kwMkeAO/2DP6SnX9ccqoLb7kfZK8XfF7eAeDPvFlWDM61GF++gX++fB0v5c/HJ+H7CUwEDTzOTwAYCLwv7/O+ex+Ax3wahyMSeSKfBSAQyJKJvtTlpDsWZh7rGwAcpYjL93nfQ9uKOIJ6Bq0rrhAcjrm2x0jA43gqNz307WO9IJL4cn6/V8k20PCFXvANveEyjwz1eFLlJiW+eF3Szap86ZD52Q/KNYs4virPcHg+WEq4+Dk+I+v/DFquKSuezpYW1k9ujr9z59jaXndZ4vHs3G27bl+nk7Pu3FnT2fttP27hw7fnOJSlJyhIvb3rn+c8b9KDRSNaV12KBLLOOB2J3NZjjtvlm7zHb70gH3f5Lfk6Wefebkom5VuyRg7LN/sxNPf6L+kufPTY7Gdu6uDjxtl5G52f3z733G3/F61/3q6/zmev3T3nn+fjvn72Mp+9SuTs98uc+7JznPHt86K6/U6ssNz2sU/Whg8STcMwDMMwDMMwDMMwDKNhDyMMwzAMwzAMwzAMw3hQXqUz4jtKE5+pyolIEMBPCzl5/FSWiw0XB3b7A8tSRIHPby7wonzw7DE3xwko0snn89TFkoPL7Hwi1eV/uy5G28gb6+/mF4vJE3zCV6nY4DKpys9afkUU73IXWS7J41BStZpFPINkFpcZfbnmcoBHyXOTqviOsjxu2Dw6qjrGLmNLVWbWJJGja++FXfU1Oilit9DPgZ1fl9TsvHbxZtqIPNNm1Y2r0sImxQtShHBeVlFbW+jW81Kva5K5TBFgbs/JCirr+/LbcRO138c7mPzmHKdddljqwJFUicnVNFZR5VZguZXVuU079dcuk7LDuVYXjmGTRksvxkCu93Y+93SAIlkNiSgb8WpI5OyIVV66P+y4jusQPOYib2yivNEVaafP0hcaOgTB9eWksdZpOFtqJQhB1g4TgLgRVp6L8Rrt3oMr/c1vkl0obdb6z+SV0Wf2oSzjfLQ74ESZ6vttPQ+1fsZx7mOh1VfODn8sx2LyxOxL/da6nZ1nR8TVervwmVufmXx5/zyW8m4FnFmLEHaSVk93l6K5Lo5cx87kXJdeCmX8tLq/8J64kaq2enLAsd54dBuVoqzplvY4OdzFloOj5z2dNUt73xdxbqSwLZ2tXBZg3qyYS7q2oduM0fa7yGrXRcv5TIro6hgTp7g6Aw7DUua1Jrn0menqpstclxj6vDTGdYnsbQw9rzvnyG5bj3oiuCz1pDin69jyCZeFYYiMY5nrt3NKz7PAIa11u5x9X2QVBO39MLjELkQua789Zo93WkSe9d5JMzn7LswNVZ7b3o9OqmR3OxcrQV78xD+qklV7Pyj3UZwIE6VvBxUWMlLTPHDgWJeZ5813omEYhmEYxuuIrYwwDMMwDMMwDMMwDONBsYcRhmEYhmEYhmEYhmE8KPYwwjAMwzAMwzAMwzCMB+W1cEaolr3kAMfD1Pcw57pH2Y8LbohQ99C6cWHYHZmOY08jJs/1ccc0lH3Bt8vI6CLP5wsArmPoe33h/qc0SYWkwlL3riuCiBJ82RftJePFFUdE80j4xFj3IgNM1RnQ9kbPSZmTP4k+lLU6FNredBFi1p6/5mTQkoN6rOxlb/uP26WJ9ToFUoa61Z6kEPO69zxmQeQ0uFDbwe0225KV9ZqWdt7sdffS9smf0vZ1L3kTiGpz3TaNpGX/9Lo/X5BeLzUfeurLWLKrPo7qCaj17Db70FUFt/FMZIo3QlXW/iN60heK10Cg7uMWyUi7puU9OYb9kTCubY3LTI9L2C83JNI8nOyJf3zYMyfPs1jcJkNyDE4Z3LoPfRBhcI5UK2fRDOhLPUVsjoitO6JnbbvHHiFI8Xi0o60Pbp0Rvkb1au4SofSVVr+DTwSX+n7+Vvdl73/NSygujZN8LqG7CmQZkNTGRhnfg0tkDX1/frvf1o+SsiJnHW4bFOucrCU8mmrZu9+OZVorF5LqSdCvrUOm19M96UdVgqxjw4n2/u+q76GlvGRhySXt1t9dFnBKTqcumDVf5Vx5gQvjtKz1mk1Gm/MlqTAnh9Y+N2eHqpDrHJez4H1pS6l+GR9SGQPVp+Dq/Dc2Z89txEkmuNTH4uQjc3ZInccHp0Rd22c7Tvt8pYJIXsdZdqQYSNF3V0tGTuq/lfUkIGL1jxx7+mWObn2yeWRa+yQVXF59PABjLeMsvl+z7VsxwyFnsvruqMiUtj3U7r6ocszKnHPP4+BcmW9V+zm5/rQ0MrmPV08gEBjlgn0u32/b+c14CATZ/OmkJE5Dc56HXrx7/X3hAAUPNVymd3tE1nukfEDzbU19tVgJ/uR9swqVJB1orvlbwwOqLiRdarpPmaPjejOKPpTfwMmef1G/N37p/T/NZ/Rf6uE094zcuhtSDbeZdGFkz2fzZ/j8roQM/b4LZe8v+dax+Zvg6QKPBnhaI0F6B1dh/RvggxkuwjqGvZTvmncPyhvj6d8+bT68DMq7h9WL9eld5lHI3KQ3ujdGgcsw8K1jOWnn9eTviMdj5hsHjxN4cyz18HwRRg9Pl5LG3iuDg6dLKd83Dsrn8xt8Kx75p+5dAA5aw2/WdhONcNI+jY/6ZqK3X7tOxJ+F5Mz9THoJPyntW63e9+RvBYfgcW48ORb8ntFdAjC4C/buSQ+5OejU+wWA14FbnjLKvvRvIHIsfaaGl821PEd9DsAkV3wQv8zgLnC1LudUPou6hjj1MuBkINe+PKdrsi7E1OoqI5pP5vGXC294n4NHz45v/0pu3wn+7PPzO/hev4JDxJFbGNI6TkWGk7Cz5a8Gd+f19vO7Wd0ckxL89vza83RP81nzKJuwrWd/QwrubjjWeo7W9mjl3d5XxPWwryf3rsfKXHUazrT0/fP/R/K64M/el7/fXz1lXBc71nnY3G4gQ8QjlP//EfwjnAt4mU7OduL6saRHvEx4KdeIOJZ8y+D2LPX76fnxt/gk2MoIwzAMwzAMwzAMwzAeFHsYYRiGYRiGYRiGYRjGg2IPIwzDMAzDMAzDMAzDeFDsYYRhGIZhGIZhGIZhGA/KayGwzAiHYxFoiCgpepYlEKoIzw8LfojoN94s57jMzbMrbm6LIGeeR7zPfN+n3sVV6VpcBp49v2TOod4D3j9OXZ40byRk7ZlNk+wdqzjz5jjhZJWxeKe4VOSIsQrglipskyotUYQl+S7ni9lxzJ45eebUBGqcSI+SFtnbvHEYLaoseRXeNdmj01Vq5KWI/ZaaxSYebKK2rEWw1o7Puaq57hGitVIWieeqQJlz+VnyKpVqAsutpHKr7Gr5HkRYdL3XucByztrlgosWXeeShWNtm2MWxuS72HCoAkufVmmMiHaZaHtfBJVVtlPTElF8Fcv5KraLcRVWHuexyyfb56quii0hRY+qkOahflbkpsP+UMq2eI6HiRQ9x7kIoZbkSOqKwJRVeHes/SBq+dGN0G4hspC65CqRcDh87aMOIaMEfBdDTVU8tpUd5o2QKfe+ufa7qs46aY8mtGztXCSKq9B1SZ4xLIxVEutcE3BltNW3Sq+b8zZpuLN6FlnlsQDH7Mi1H65prFJHaLLA1MuTazmbCDBtOlu7JqoW4au08a73aukWzQz1nDI2FddllSWNLQ7pYtnyHrxIvwaU25RwIr2dJ+cYdG2xIKUvbOWUS66C0DPh2SCrKHbLnMu5TmCpCQ1OyOq5COXk/TJwiIFj7cfeR7xPOJ9P2gxXJMJQBZHz0EWTqsKSAsc4cFvlrNfLyJx8b8OoqzAXwKtwrFLKVNv9GAM3t3vG6yIt0ywcb3c8f/qI958/AuDpPPJ8GU7mziVLb4GsVdSrgs+tDxa5bc5rnyznrvmf1XOIofdth3JIgds298fAosLSrq33i5l+7Jj8yTkpa5WOUuu+yCujapcVO2BBe1smMhntY7TcK5NYTo4ZhmEYhmG8jtjKCMMwDMMwDMMwDMMwHpTXYmWEYRiGYRjGJ0FE/g7wI8C7qvqv1GNvAX8f+ALw28BfV9X3Pz41rSHo1venv89ff9SxbZoRari8mI73nnP3yHnYtrwGftZ05/we+nMTqk8YNuEbHYO/ZHB7XA3fdpPf54v6TS79OwA8T+9yOH6Ad2W16ugueapf4zq8z+8sJVR6+mDBiSdrC3s+oGTyIfWwcJ6ByLGH/tvrJXGOHChhHHdc4XBEiexvLmrpMtfyIZ7Q31/oI45SViByW8IDCr6Hilw4kDWy5JteZi8ToeZ/ybeopvJ7E+Yw5SMpl3RbuMLWPmXl0nlYxW9npdJ9bXN/KnpvO36n0J4XvefmCuR0fXIsJjjcSedlwmd+N/Myed6ek+68/rh2uq9+75yjd2v298V3qim+3erh5cr7h59XOXY/ijKu76/+vmYd1YRSwrfO8fres799PlmZbWWEYRiGYRh/mPm7wF8+O/bjwM+o6h8Hfqa+NwzDMAzjAbGHEYZhGIZh/KFFVf834L2zw38F+Kn6+qeAv/qgmTIMwzAM4/XZprFU4aM7TkWYFgMhlCVzPiR8iF1o6ULEucw0lqV13mV2+wOahevrstxPVbg+7hhcuebCR+bgebqUJYSZKmrUVQQnvixvCVWCOQ0LwSdylfMNLsEAO7/weFeWBO53hxPxW8t7k/QdqzBu9p5QhXBeimxwK72bPPj66GjJTT6pXb6XaQLEmllXVH1NWFfuXX5vRZEnC8+0iPIygqNJBE8X4DUZZUvTSX1/dmzLVnhIP1fwji6AbHLEVh4vEEQIssr5RidcBHgylDZ7MkSuhqU/UbscZkafmGq/2A8zg4+Mw7qUVSTjXO7yOoBUBZJNuBijR0QZx7nWQSbl0+d2MQZElKUK7VSF25sLXO1Pzpf7zMexX5OiJ8bQhXneFblmE3BOThnqD5TyTx6iui76HLQtT20t53FIFzMWmWV536SWXhxJM6EuzZVSoV2g2GSMrd+V16eN2NpOKfJBgIEin2z9yrvMbjqyq9JOcRnNDnGZ3OrYJ0JI+Cq5LOcpu9uyZPZ4mJjnkTEG/GFdBju4tIoysyNl6ZLZJRcp5jFrlxCWvK6Lbpu88j7pXytrpvS/JpF0Ir0/AkTNOJGNXnBbPxsBZ71PSwdhfd0/B7+5NlEFtFvJqK4yzyadbfcZpIxrL9L7f5mzlG3TqdL7zpK1jsVtHVXpYpb+3ol2eSiU+XUYli6s9OOC86m3qWZHGJe+YHwcZ672NydtEZMr4tFe5rNJAgiieFGGKpwNPjMOS5/XVaXkzSd2tf9choVrP3BTJ8dFhTmvc1xfQH92v904M01lKbyIErMn1jE+JY8IPJluCb4uM3eZmDy3SxnPN8vAs2Xs6d7EAYdnH+BRze/kE4OsX7GjFy7U9TFW5toiFt02Ws5rfxGEgUCr3aAeJw7PcKf+jG+bz6jqVwFU9asi8ukXnSgiPwb82IPlzDAMwzC+R3htHkYYhmEYhmE8NKr6k8BPAojcE27KMAzDMIxPhG3TMAzDMAzje42vi8jnAOrvd/+A82MYhmEY33PYwwjDMAzDML7X+MfAj9bXPwr8oz/AvBiGYRjG9yS2TcMwDMMwjD+0iMh/A/xF4B0R+V3gPwd+AvgHIvI3gS8Bf+3lU3zVOzVa+lL/19dwoi9/3xLCs/2JVzwsTvY4NyLVWCPiCG7fw1wGmXgin2Vix59wnwXgNiWcEz4zlbT+7FszFz7x+UcfAvCFz3yN59eX/Itvfob/6SuPAfjN2+f8rv8yj3hS0s0Bh+Or8kWclnvP+YakR/b+zfKeG5TMFW8DsMiRWW/YccWHfLPmv16rt+UcDtzo+6iW8iVdmFMJ6Zlycz6NxHzbz3EyIHJNruE6VSNZYw3f2aw2roTxrD6lErYxf1v1/72F1YthGJ+c1+JhhEMJbo1dmrMHYhdDOpcZx5mwK18+YTcz7o8cnxdZ5XwcGcaFZx8+6mksy4CIEqqo7WKYmULkcSxisGfLwDF5fJWqAYw+sfOJN6qc8tHFNVdX111SKCjHOBB84uqinDNNR5zPPa9F+CdcHMqXf0qe3fUV+5sL5ipQi3nCieOQmuIOHg9wUQWai8IxCYckHGu1NPlek/F5gaHKJ0Nd/yIUEeFQ318GZXTaJXleSl37jestc7p8JlXXWvPxLSockquyPWo6pYybr/Ve7m2a2yjdWWtk3Lymu5yE8RYuvPIDlzOf3hVB4pvTLbuwyil348zoI0OV203jzDAsTLs1ZrvzGT8u5LQpVT6V283zSE6+t5mqkKLv+Vd1iOQTGSUUGWfOZUiF2j/b5yJapJjT3OWZT1LgGAO+igFvY0BkYHSl3S+D491DEd61u4zqSBq6yLBJFX0TWEoTWW5qToRVl1jFoFnq8VUUuvPS+8ajAQbR3ne6fFRgqJm5DIm3xpm3L0p84rcef8iTNz9gvCzt48eFvARwufwG/LQQdjO+tomEhAyRWMdquh2Zn18QDyO3Nbb8o5s9x3nsstB9WLi83ePdvtS7DgxOuIlFXgigONxmeouqOJEuBpycY3SuSiBru2dlydLr0Mup7HXR9oepY3Dl9ehOxZKtH5fXG2mlCNte5mR7bZFybhmcMDo5kcFu0/YieC0iyya2TbnJZzfXAF7Xa3KV1IZNut7Rpamjy0UCW+WOl5c3XD55xnR1gzSppSjpMOGqyDcnVyTCTRgcEtPuyDTOHI47AK4OO8L1I4a5zJWDDCj0uXXnE6NLDC53Ae3VdODi6pqh9pWcHFkF55TB13PGmUMKm3oJjM4R65i+GhJvjQuPh5mh5v/JdOBif8vlk2cA7GMghITUVG6rmPJyOrCvc800Lohklio4PhwnPry5ZKxpHtIlg/NMDt6o4tvLYSapcB1dbWfHzrs+xoK0tpdNn4E5O+Y690ctfeuQ631zJOdHHOXIlUy1zBgfg6r+ey/46C89aEYMwzAMwzjBtmkYhmEYhmEYhmEYhvGg2MMIwzAMwzAMwzAMwzAeFHsYYRiGYRiGYRiGYRjGg/JaOCMywpxKVgcSkspe/O4gyK7s889ln23byyy+CBWm3YGwm/n+7/86fl/286abHfOzC9776qcAuL655NntHn8oe5zTxiMQulNB8ZK5mso+4kePnnPx+Dn7Zd2Pf5xHnMt9z/W0O3dGZHB64jEYx5ndMDNX38AheRYdyBsfwc4rV8PqzViyMNefkt9ST3mzt7/tx56aM0KUpMJQj1+GzOhXMUM7P4j2ey96n4OgpAMw5pJe3uyI9921sL1mTSNvPttet90Tv2RhydJdBYODRyHxqenIZy6LoOqN/TUhrHUyjUdCiISh7CefdkfCNDNe3va+4IaIGyK57l3XLGgWclyHQjiMxHkgzWWfdoyBGANz3S+uKjiXSSkQo+/HprpXfFtPzV+xLAM5Oxy559nJiRSDrMLkMmmzCXx0jiB0F4gCSz6/bnWF5OpGiJvKD9AdB1DcIRkYNmk0X8To2n2VC6/sNv0jU9q6te+jIfKZy+d89u1vlfb41LfYv/0B4arIxdy0oNXNkatXBcq4dHUcuimiKt1Z4HdHhqtblud7eK96GJJjiQO+7s8fXEI2++SDlDJt9857KU4M3XZC1v6VVFEUWN0kqe7PbyUuHpTVM6GqvV59T/d0w35S7Wm0GhcRho1/wkmRy22zpjWlpR50CjHTfRCrC+b0fpl1Es81z4nVX3GetzbGfP+s5G1f2/mN8cjj/Q2PnzwF4OLxc3ZvPC+Oj9pGeQmgQu5Om+JOGaqzxw8R1+feMs9d7G+LM6V6QAbZcUih1/XkE5OPeNHugbnY3TLtD4Tqooh1POYs+Jrf/TBzGYfu13FLKP2z1tsgyj5ELoeFsXomnlxcc/X4GRdvFQFfjgHnErnOpaHmcb87sL+47eUQn/o8savOn5ul9Ot92JOOgYwy1rI/mQ4cU+BqaL6H4vnZ4qT8bPtGcUpU10xWNBc3CMARweHwBBzNYYNhGIZhGMZria2MMAzDMAzDMAzDMAzjQXktVkYYhmEYhmF899JWvdz3bzyfNCxkXZVF/Ihz1vCf3j/havwcAF4GbuK3eHv8I/zUv/wGAD/8t3+Ww5/9YfKuhOB08zXhW79DePd3S1LzzPx//zbPvvwZfvYXSrSi//a33+D/SL/Cux/+cwB++v1nd8upseazx4UB3BoHSrYr88pKIZGAauQ5X+75B/gG62rHHntLT8uvL6zL/ILjn3D50CtZdSQfkfD2s9af9J7jthzKMIw/PNjKCMMwDMMwDMMwDMMwHhR7GGEYhmEYhmEYhmEYxoPyWmzTkJPXRV6ZsiNoleMlxTkHdXmf+IQfIsPlbX8/PL7B7Y/oUors90eQzNtVNnb19JLhm29zjGUJoV+UQTOqQqjiPC9FTrbfFYHlxePn7J48I94W6eXucMD7hA+JscoMnc9dtNnLIIqfyufiMhcqqDqe3JT8Xt7u2XnPRbXXRRVGt8oEvSgxO7KugsklC8oq3pQqsEwbOaCjiCZdXeI3+owX7U+kmphwcLkvdvTZ9WPQ5JNreY7icOJOhIntfsuJBHQtf5HsCV6UZbPa0LEKLcWVfHVRps9chszVOPNoKvV0dXnNMCw9P7v9AR8iroo+h2nGTzPDoxvcVCR4MkQkpN4P8nFAoyfe7IqYr7aZ8xltItScydkRq7wuJo+rks+lilVDSEVQWevJ+Yy4u0tGxSl5WSsjbepycBnvVtmp6sDkleCk11+s9dWuCnX5q9uIDUs9rscG5xidkGobCcIg0j/3VZo3OthVJ+HkYOcz+7CWQbW0WesL+xAZfCRUSacfIn5a8JdlfMg+oYvr5QZI1zs0BxjLstt8O6BLQGtf0eTBaTm/HjseJ57eXBCrpPD9w57rGLiNbXyUH2UVAaYzq58TqWJJ7dcUOar2a5qocitavc8OqJv02++eRrtWFb+RhhYZ5jY/m9esedaenpSF2TVB6SLLbU7OZIj10FbIuU2/3Tfrml8BglOm2j4Xw8zV5TW7OndOj68JVzdl3Li1LnQIUPup8wlEuyRWfGL0GTfE0p4U+aRzCSet3hw+KkudX0KVuXqXmULpT5cXN0yPbroMU1UIIRFCxMfYzy/pSS9z0lM5qBcluMRUxZj73YHLd95n+tQHpa6PI5qFy2WrdC3SyrHN03Ve72kGz2469jQnlxmdchkyg6vzT4hchIUnVag7Z4fgVulw7YNLXtuqSVRTbcOblFlUWbQcuGHmVm7JkvtK7TZfGIZhGIZhvG7YygjDMAzDMAzDMAzDMB4Uexhh02oR/AAAIABJREFUGIZhGIZhGIZhGMaDYg8jDMMwDMMwDMMwDMN4UOxhhGEYhmEYhmEYhmEYD8prIbBUPZUmNmGXNOlZSEy7A2MV5/lxwVWZHoBmQZPjw1//PNcflPja3ieWZWC3L9ek6BnHucvTRp9YclE9rmLHhJfcJYUiRbTX5HtNWJiTY2kytKXkvV9TJYWuySjHBecS43RkX6WXO58YRAn1UZGoMjjt+Wj3dgjNKbeVVzaclHjcTY6GSJVKVnFhaulQy9fkctJFc7HVexXNJRWSSm+DmB3HLCcixqRNPrnmJcmpCzAjZE7Fc1DEfbCeG2qevMDoMju/cHVxA8CTNz/Aj7H3jTCWtnNVGOd8QnwuQsQmn3NafpokMjvyEoiHkaWKSJfbqZStCitT9MzLyNIEltn38rf85iwsMfR2BvDRr23hMimV67bpZBV87cc7r0R1vTyzy+ycMnnhkGqbqTI5h6/yySJt1P6+CQrHtaqZnDB66XmtOepSzOCEi1DqeOdLufahyCun1qdVSDQZYK5tJKgKsfb15TAy3OzWOxyrMFaUdKh1+nxfRIT1fR87VVKIOjQLx6eX3N5cAPD85oLnx4k5l3q7jgNz8hxrn5xziWZ/LokEer20w20INamnl7XveS2Sy7VuV+EnQFTFq7JszjlPH0BFEF3HlRPBi/T0vAiDW9MFkNzmtDVdJ0VEW9Jo5dncR5uotrxPNfx8O/fcvZn0XHlZ+o/qKt4EcJs5LS+BPAeYQxdYLs8umK/3pCYDHiLD/og2Ue4QkbAw7Y7rvQ8TItr7dsqO924ucXUs+E0/a/10WQaOzy4YdmVeXA4jyzywLEOfX1PtA6uEt/RRPas3dyZ5zMmTj2WUaBWhrnOPkLNjmUdSHcM+pBNZboqhiIjr2A0uE6RIgts87UQZfVzfo3f65zHBnE+Fq0uGpfaHQ85EzSy1hRKZKGV+i1VqqXda1fiDobVhooy0/sXLqhU+P3eLPzsH7v570enngu9228e7P8ZfHv8i/+EfexeAf/s/+e+5/Xf+ffyzr/FzP1ru98N/40f45fS/cFi+VnKh6Z57KvAB8OsvKGcpj9D6392yCB6t/5WTqtwWQTnWex9RtM+DWpS995DvvUf77C7K3Znuo8bIQwtgP+p++m2+NgzDeP2xlRGGYRiGYRiGYRiGYTwo9jDCMAzDMAzDMAzDMIwHxR5GGIZhGIZhGIZhGIbxoLyyhxEi8ndE5F0R+WebY2+JyD8Rkf+3/n7zVd3fMAzDMAzDMAzDMIzvTl6lwPLvAv8V8NObYz8O/Iyq/oSI/Hh9/7c+LiEnSqiCO+8yIUSCT10iCEUoNl8XeZ5mISff5WNhXMjJ43ziyWe/Wc4/Dowx8Pz9IrSc55F5GbpIbXCJXTXDDa5JyhJX05H9xS0A06PrVbwHhJBIIZGTI6fynEf1VJzkABXt1zmfumjx8eVzAB4/e8zVPHZ5ZFLhwmeGbXlViApLk73lIqfsojuU4awes67SOyjqJ6dCllVcKaJVBrjK3ADmJmqsaWkVxx3rfU8EllWqtxVY+nr/XleidwR7JQ+nddWkmqPLXITIFCKXV9cAXH76fYbH191KKCGhG2lks9jJEJEqtSScieyWQKryyiauvL3Z40PiWCWLAMd5IGkps4gyhaXIP5tg05c+GVO5/xIDOTuGoUg1l2Xo4sptn9iF2CV43ilZhds41DInFhWOeSBWoWAQRzyrN2UrVCx16KCfFwSC24gOFSa/6hOLHLSI/6Zanp3LVaJa8jYnz+AyweUu5BNRYvYsVWQYjyPL9Z40l/yH44Amj2Zhud6XejiOOJ9Jx6HXhYh2oSsuo8mz3O66GBPKHOCquOvCR/7/9t492JKkPOz8fZlVdc59dfc0M2AEggGEVyCtjCTESuhh2QItYIeRdmVbj/WyljawvUK21qHYxdbG2usNObAdK1sOK0xoZSSkxRISQmtsy0ayYFEICxgMDANCMGNAYmBgZuieftx7zqmqzG//yMyqOne6e3qG7nO7+36/iJ5bj6yszK8yq2rqVP4qRMc8b9PGJIQMKoPaqxYhyigwjApz5wZRYJFI1iJDfwi63v6ElH6QDoZklEwS0bSwnCNKv4hZgqkqdJN9pWSjZFSQQSAagdolGW05KrVLy8ox80KW6TLkkfKBmS/tILlZfTlvTOoOSX6aSiFDe4n5HFLkt22s6LqKkGPfL5s1ETBAdzBneWFnFKIuoF7MmZ+8kMuuiOtxs26QXrqmR3wY2v5iOaftq2E+IqhCmAhcATQ4umUSTXbLGX1XDX0L0vVgKo2snSKiQ2xP1B3bVUfl43hur7tBcgwQ+gbfdMwGmXHF4mCL5aoZytLUHaH3QzvVKFRVzyz3772q42RTs1sF9mYpn61mxaqr165TpYwALqZ+qEA9Eew1jiwaTse4i45VTPt1KsQYiaLMnM/5mNDOMAzDMIybk+v2ZoSq/g5w5tDiVwJvzNNvBL7reu3fMAzDMAzDMAzDMIwbk01/2vMpqvoAgKo+ICJPvlxCEXk18GqAO+rtDRXPMAzDMAzj8XK5z0kq6f2nx3qDZZpmPS+RmsrvcdvsWTwj/nEAvmJ2gu986gHf/6o3p728/CThzW/mF96SfuN55l9/MQ8cvBnVbpLT1Xxi9ErLy7pw1R+ofPTyUrdUljFt+W0srq1/dJkfi8f7qdvyGda1DzRPlhuGYRjXkxtWYKmqP6OqL1TVF56o5kddHMMwDMMwDMMwDMMwrhGbfjPiCyLy1PxWxFOBB692w8olx0JVpb8xOro8rjlGT9c2VHn8ruRxvWV8r4gyP3GR+uQ+5LG4GoWwnOGrNG64W8zYv7CLZi9A21c0PtAGTxmJ7iSN6S8uihg8TsOwn2rWIpLGi/c5jcZDY6DLdC5HDH7Ypowt9m7dD5E8D5N5IEShjY42rLsdGjeWde7Wf03wTumiDGOWZ5Px/8Bk3HVc81Woylo6EaXNboSoHu+VoLL2u0YtOvyW0cc09t0Xv4JLY7xL3oWo0LnRgaFrZVIaF2iqnmbWpnjvLvAnDhCvQwx0WQ2uiDV/xLCTHPvik5BxDHgpi6pDYxwcD95FlPWyer8eWyeK93EYyw7gJvFvu5oYfSqjyrBN48PgjCjHuMQ2rdPkApASe9CJbCPq1EkwplMdp3tNzo6pDyFO1pfFU4dHZP23qAiQj3E1dZdEGdwBbdvgFzPqMt49u1DQ5HBJGQkx5TLW2cWhT4m4wTMQwhhLkTE+jQ/UIQ7tLfUVSc6HXGjvWHMweEluhTIWv8QgCtSTmAXGPBpPznf91zEnKf9SLicpvgBdHH8HFZ3s28ng8KjdursFTWm8jGWrXXJaTJ0RUUc/RBy2gZmfOF9iqkOaH9NA6oeHf18snozifAlR6Pp68KW4qscd9DgfBw9Ot5gRJ8dUROm6ijq7QsQplUSkCkid3ThVwM06Qs53e2vBxcU2i+KmiJ5Aclescr9ruzr1xX7aDpQ6n7NTHIRZ1dMUp1BuC4c9DSE6gqR8QvDEriIWb0nwqW3nPt00LTGk60vpq97H0WuS66jBEXJ/b6Onj0I36f+qQhs8qxyn/d5z0Muax0Rg8FsUnEttBEARZPKLbYhKrRVRldnQCDEMwzAMw7gp2fSbEW8DXpWnXwX8qw3v3zAMwzAMwzAMwzCMI+Z6ftrzl4DfA/4LEblfRH4IeB3wUhG5F3hpnjcMwzAMwzAMwzAM4xhx3YZpqOr3XWbVd1yvfRqGYRiGYRiGYRiGceNzwwosDcMwDMMwDMMwDMO4Ndm0wPIJ4V3k1IkLAIOk0lf9ILN0Vc9se0m9u0jzTYtUE9mYD7impz2zR79IX+ZwPhCDp5q3eT7im34Qn4XgOGhnRJ3RZylZkv4pPu/XNx1+vkKLFM9FfNWjKlRF8Bgcsa8G+RuQhZU5z/zVrb6rabPMbdlXdCr0RXJJemrkZBTVOYHGRWoZ0wDs5bLVLjL3AREdnjhVLtJHNwgTaxfxLg4iPZdVhpULhFy+oA6H4rOMMargJgLL/a4hqAzLAbro8KLUeZtVdLi8PwAvEe+UEGWyHxnSAiz6ijARZ+5UPSdnS/a292m203H2uwvcTkRz5aVN8dYuNevYVqg6/KxF3UQA2ns0Hw8NHo1JmjiISOsOX/Vs62LYJkxEpCF4Zs0KVRkEdvP5EnGK90muVzUdGh0+i/XqpiP0HnFKu2rSvtVxsJoN++hjiul4nFPewiib9MJwzAF6WBMdKqMcsVTZTSSGKd91meWUsS2sM5WTlj4yLMsx6LuaftWMItZZN9TF5TgEqonEkqF9ykT2KaKDWDTVaV3Smtbr0DZKXWuX+mgqVLJKTqWQaT+TOskoCoQkpYxxDJwDas8g6EwC2yTBLPk6WfcHulwgL+NxrEWYeagmAss4ib+ShJXTZUW4OXwEL+9nXmStJVbALJc3eghOaON6PmMdJQs2dVg290l62+S2XySzRSjarxqcj7k9TwWvbjimVRVw1XjuHM6H0UHMhYmyJontupq2r1j0+ZwXxv5+YrZKZZu1zHYPhny7SVn6LMv0LhLVDdLLi13NQfCDqPRCX9F0DSE6ZlWqU9dXhLYmZIEluT6lDYpT6lmLr8JYJxWcD2i5FkRH33tWufwH+ZwdGfvxsmvY7xqW+Vy5iuk4ukGIDG4iny1UomsC4XTEcnuLgsvTVW6D5q+8UXi8H7sURFL7cbJFXe3xzPrrATgdT/Hs+S5/4c6HAXjFX30Ly5e+GImB+gv/KW1z77186q0v5K/8wx8E4Jf+t1+j68+hvOEK+w08MYRyxhcExCFkASwBtEcHdS+sf5azbFOBjvLZ1KrXJdNZ1zxso7jh7zqX+9TnpT+N+mgOfy70Up/xtM96GoZhbAJ7M8IwDMMwDMMwDMMwjI1iDyMMwzAMwzAMwzAMw9go9jDCMAzDMAzDMAzDMIyNYg8jDMMwDMMwDMMwDMPYKDeFwLJygdN/7EEA6p1Fkg3WowjJb62Quk/CNMDtLQHQRRYsRQFRmjvOsfWkJITSJeAgPLwNQFzVaBT8JN/6YBvvIvurJL0MUfAuUjfJOlltL6lOX8CfOABgFlyStPUeDaOYqb+4RcxSxSJwG4R+eblfzphd3AFgt2nZaWcsqjGPraqnLiI3FRoVGhgkfpBkbntVKtu86ml8oMqSyhLHLoyHvHKpDCLroqbah0HaVxikitHhXaTNwriZ7wdhW9lPiC6JCQehpSdEoSkyRxeo/Ji2xFYRuiJ/66s12eZW3fOUE+c4ffos9U4SS0oVpj6s0dhYxIZOEdcjPkLeH+UYxYlQNItHBzGjC/imp2naId961g71AZjv7a9J74rUtFCOc7W1HJcFTwyOfpmklQfnd4lRaIvEr6uJ0bGV5auCcrKvaGeO2qW4BBXaAJEiuEt5FwlekSAq65LEmdNhmy5CJaMU0wlsZzHiLNen8ZFZlqCm/HUQDNYyyg69U1wR/8m6VEx7jzQdMMpBxR9Ko0Joq1Ea6SPQp5hnWe3WbElUoW6T+HNWd2sS1bmvaKNj5h2rLCZdBljFdTmgk1T3Ml36U5EFlpgV+SGsSyR7TZLJZUjix5KPl0nc/Thd8pl5aNy47yKcLG5N1XQ8k1wy0bgklhzFpUnhtpPbRsjbOHSQWs6DsIpuEN/mLkqd91c7xzIkIWcRWO5Uyqk6cDq39dNb++xs7w/tuchCY3DDMfRNx0wirs5to0qdUIr8sh3FkOQ2IVUkLBqWj+wCsH+wzbKr1wS2IQtf6yyB3bvtEbbuODu0jWZVpz7UJykwQLu/xc6FneFctgwVrGbsa1oforDoqyQvLf1bFPFhKC+up/IBP0vtbXZif6jPIO0MSXLZL1Mb7BapD2/VKW5zH9jynlqSmBdg1dW0wQ/7rR3UKPMcx1pSn4y6rt2rROlym6yd40InSQAIdFHpQ4rvdpUFlq2J9gzDMAzDuDmxNyMMwzAMwzAMwzAMw9goN8WbEYZhGIZhGDcuMpny6ZOXebqubqf26c3Hys3YcU+ikW1euvUVAPzpP3aOb3reR/myb/03AMSLMx6+5yt483u/EYBn/M1v5PMHb0e1Y/wkpQLvyf8uVY5r+caMUj4Lqvk/SnuF9GHtb9qmP5RGrupjqI/+mPF0/rG2fqzyGYZhGEeNvRlhGIZhGIZhGIZhGMZGsYcRhmEYhmEYhmEYhmFslJtimIY4ZX76PAD1k84/en0TcHtxtPg95Q50vkW4/csACHtPIc5PML/9mxCXxGOqPW37RcL5ewHw5z9Dc/8nmH3i0wBsfeYsy4dPceHMSc6eOQ3A/nLOznxJs50Eiv7EAe6UoqskPitvT2rnxum2Qnu3JtzU4JNwE2ChaPA4H6iyCG67WbHtt9iqsoRNZZDtpbKvyyUhSdm86CCJLPLK2oW17aIK/UQaGXSURBa6UA0CyyJtlInA0onSZVHgKlSDdNLHOO4HGfa97Cs6dYOsrneOmfY40VFgl8WY0/rMfT/UZ7tp2dk+YOvkRartJIUUr+jKoX22CUZBu2qQU8bgcQRiVw1P3TQ4Yjs2+9hVxOCTFLW8UloL1Xw1lsWHJOTM4jnnA/PT59NxLILH7SXaVcNx7S/sIHU/HvcoxCxcLOK8eXDsrmZc3N8e9jWNQ11N5aDNkGa/94McsY9JKumLPDAKkfU20muSJpZj2EdhOXlLVQQqp6imvwDbPlC7SFMEnaJZKKoTEWlkVnVUed65iK8Cs70kdK3m7SgAzOWZSgHT8fCoCqJpvxHQWBP7apS9uoiXOOxnXrfsBM9O1wzbzFWAmmroJ0kcWE8etzqgn85LEkFW+ZXeUQY6ykFr0UE06SYxLQLLoOm0syYQzdNl316SRNLLOO8e1YWToLJIRudeaZwO8kmAxkW2cxvspmUZBKKOKirL3DcbUnsoxzT4VLioMCvSSx/ZqQK7WcS4M1uytb1Yk1X6usc33dDWxQdkRwcJr6sD4gP9QRb97idhb3dx/Vl339aELJ4cZJKM55WggqqMUsgT+1SnLwyPzMO5rcNBo9paUjUdIZ8DbjvYTX0gx6eNjqiSBJn5XON9oNk7oNpN53GNkvqyS33ezTrwEXERzYLhuKoJq2aIgarQ9BWzIgz2PXNfEYFlFkymeo7HZ8tHKhmFo0UK20UZjmeJRyl/aTN9LG10bA9l+tFXA8MwDMMwjJsDezPCMAzDMAzDMAzDMIyNYg8jDMMwDMMwDMMwDMPYKPYwwjAMwzAMwzAMwzCMjXJTOCMAqhP7APjbOrhtG7a20Sb7H+ZbdKfuQKs0hrw//Rxk+6nMtp4OgGifHREPE5cPpQxdDWEB9S4AcecOdH4/Uucx7lEIvadva9o8brgLHpFIvZXGFvuTHZzYRrbymP+qQp3HXTgHF9O4eT3b4buWsEhlU3UIAcmeBlf3qFNcV1Flv8De1oITyy32+zT2+CB42ujosguhy+OMAarJgGE/8UrUfU0tcXAJFJbBE3I+xQdRtoukp1NeIl0eX+0mywuS/QElv1V0VNlZATzKN9FFR6fCdh5vnVwWES+65jaY7rfLeRa2inPAB/xW/qRYpUijSD9xXkzq6wFxMS0r7oLegyRPR0GjoFEGl4OvevzE8eHrPo2hd8UZEREfcHWPVHncfNPDrEPzeP1qbx+pAlLn9bM+uURg8EhoFGaLOas2Hec+uyu25smJ0XU1B+0M3yohFo+B0IY0Bh5gFaF2MjhKggq9JpdB8RKECDoZWR4irOL6SPMyNr3Jx/UgeOaT9X12jUzbWOcis66h7VL567qj6yrmJW+JuDo5Ikqda1FwkZDrXBwSxVFQXB2h7WlXqc/4nH81Ga+/VbeDuyK0DarCMggHxWUSoYuClnH12etQvBCqyc8QlbV2lmI4/u1UiHGcd5M8IDsiuPQH56bpWIu30q9rWhBJ+yqpguYy5jwqSU6J0qfQ0cVRfANtcEQY2kbKQ5BJfaKul1FI7o+6uEF8RJwO56cquyL8fIWfJT9CFZfJc5OP6dAH8no/69AodPtba84QVRnOPcUZsQzp3LrfVwSVXP7cT3wAB1Lnspw6SPU5dN6IXYWvRglKUDfpH0JQn/KexMxvL/Gn0jm6nNykaFnqLPXoIvFcjlZ2/8R+/ZLpit/FRWpROhUutvk65B2LXC9IrpYeodfxY4VeoA3jMYw67BpIbXgVoMvbdKooikz78yUcQsamEQ7/tuPdCQAqv8NWdZq/dPJPAvCab/ggz/6+u+i/6mvR//cXAbj7t7+Zn3jni3njWx8AoO0fAu7J/wpX+6nOa/lJz+tJEexc7rOd03Yth7Y5PD/N82o53G8ea1u5ijSGYRjG48XejDAMwzAMwzAMwzAMY6PYwwjDMAzDMAzDMAzDMDaKPYwwDMMwDMMwDMMwDGOj2MMIwzAMwzAMwzAMwzA2yk0jsNQskSQCMUJVITFLy2LEn/8ixTTnzz+MNltw8REAqvOPwGpJ9dmL6CqLC50idUR2JiK088Lis08C4JE/eioPPngH5xfbXGyTKDOo49TO/iByoxbY2iaeOp3Wn3oyYesUEgPVuc+nsjz4Wapz56j2U1n0AOKiHve5aAjLGRzMk2wREInIRJRU5GuDmC6m6SSXXNfRFbFkqiPEOMreIhDiKHfrDonPypZe3LDusGRSRKlER5lmdKNEL5c/Hsq3uPrKfkWFGtbLmktQBHeqgriIH2KiOKdJMpmX0Qs0iuzl/TnB7/SPfsTmhNFCGPB9i2YHpt9eUi8bwqpB+7yhOqTucX06zq7uQXSQBiJK7CrEpTKVZThFl6mdunlLXBYjHrDVQZXSulnauW+6Q8VUIqPcb3rcBklhTLEuYsMiOSx+xMio2IqHXFtFUhny9FTcWGUH5lSYqCrDcS5ixJAFgpCOfd02LFZJdVkEk6uL20P96t0FGoWmvpjL6xCJxCz56w5mMGkHRRwqTmlynPquwrtI3/tcr1SGIvXsLyF2TWUFJ7kdo2iOFyQhZ0EmzbV20E/iJowi0CGGDmo3Sta8PFpqpsogGXQCDh32UySYZV6ztNDndGW/02PZq+CVSb+TQS5b4rca4jG2m6gMAsskq1RU06lrrL9SuVEACeCbdByq+QrxEVf3uCzuJbok5M0x0N4jVRiFlrsHaHSIU+LQp4R2f4s6p5k1LSKwGkS4jjYKXvwg6axP7q+fo50gTQ2VR/pUXqn3CcsZ9aG+VM456dwE4PATaa3baoern+xVsLeL5vN4nG8hfYcc7OPOnU3pLx5QnTugP7sDQPtIEh/XZ9N+Z1WfpLzAVjWWpZsIRpdR1pR53ukgoy3CSi9ZMlr6d0lb2rEIgqcSockN87Ck2DAMwzAM42bB3owwDMMwDMMwDMMwDGOj3DRvRhiGYRiGYRw1TtIbMjuzL+NU9eW82H8lTX71bK+GF99xnnd+Pn3a8888/Yt89TM+zR9+4XMA/LO7vpZ/+46T3L/6IP3w+trv4uQ9lN+HKn+CqD2S56Mu0PI63y2FXmb6UvOPN93j2ff1SG8YhmFcDfZmhGEYhmEYhmEYhmEYG8UeRhiGYRiGYRiGYRiGsVFujmEaCn2W4rmzLZyNSPUQcZHEklKfQbsKDenZit9dZNFh3lw0iQ6ftovUWSoYI2iEMxdSmn2lP7PHxS8kgeWZM7fx0IUTLPqaVUhhqrPkzTX5dUkHnH0E9/mH0+zsk9Tbc9jahjanuXARVj16kHe7qImLBs0ytbBo6Bdzlhd2uHh+D4CzF/c4u9riQp/2u+gd6mUQ6wUVVJOIcJBCSvLJHeR86+gIPlCLDmnKtt0hcWQRxslkusgTlSSDK1uoCj2jIM5n6eIULzrkA+BUQHRN3qZZyjlN5yUSpEj/lMZFmixF9JIEhmFVE/aTMFF7nySSRaznFJkpUlp1Of5TI2EPRBmlnE5x8xap+0GSqiU++bVbqfuJsBCkCvjdRd5fFmxuZZlcSPI6XTII/gB05VO+UQbhoKt7mqYdYlBVgRDcIO10Lia5ITDLefkcxyIprB00TgfJYlQd1hXK8SvCRJ8FivVUYJnzX9vP9BjmZVM5aQS66GlzO121DU0zvkqswSN1j+TjD0lEq1FActycohFi7rvxYI7zWYRa+nMVmM1W9DG17VnTslzNBnFf4yJBhcYpVDl2wVFPmnmSQ4LkZaIpZkXqOK3nfPQcrskro6a0QYV5LmOIsiYQLG06iTTHvtRrkoSWuNWTfYgojnQc/XCMkih2KtdsfBz6ciVpu5pReFq70mfHsokb+3TtxuNXT2I3c3GoQ997lgdzXJVEk2HVgItoFKQae7q40Zpa+k7I5+M49CMZpK+uDvgq0BYpaz6HTfGS6t1kAWR1+iLypBlkWSWLHujSfBbSaueIq5rlQTon7HcNy+AHqWkssZzIcL2PSBXQVW4MfY+05xDNbWdnD+k7WBxAm2WUlUe2e9wqnWv8YobsT9qNKLWLdNENsZz7ji6OB3qn8nRxbDuVU6oKlkGYlThlgWWbY1tFoBFmQXKeFTELT083WYh7YK+PG4ZhGIZxc2JvRhiGYRiGYRiGYRiGsVHsYYRhGIZhGIZhGIZhGBvFHkYYhmEYhmEYhmEYhrFR7GGEYRiGYRiGYRiGYRgb5aYQWCrCwRdPAuDnK/yJA6gUfypZIeWkg5Pb4wbuJMSI7iYhJFWNOoc6h/RJzKbO5W1vS38P9qmrh5k9nPZTZXFiVBkFkNGzbBva87sANBcegRjoHkrbhOUMJKJBCG1K0x3cTnswH4SJUYXQV4N0ru8q+r7iYLHFmf1U3gf2d3ngYIsLfSrjohd2qlFStooyfPG6+O1clr+5vE3llJnzSXqXZWhFP9dOBJZFhgZp+1p0kKjButyv5OEgC/oSnUoWJGah2qRMAL0mcWaRI1Y5FiG6Qa4XVaCCZRZwelEaF2jzfOUqlqsZoR+brN9bIF6H2IqP0AsyaOM/AAAXf0lEQVTqRiEnJGlhdtOhwaHLUXaqvR8ke0Wy6GYtkiV3ADILa9JLmUXkSfMUpKZO287mg1QPQM6dx982Ca6rknjPARcOhnSzCwu2F2m+tIUigVQVKh+pXPqXiii0E2Ool7SLUOSmUYbjXNqtI8lO/USoGHUSIJIQMzJ+SX0ZPCJjbGsX6XNf6CYSS4BHFmPfq+uO3VikhT2u6cFHCKNQUFSSAJEkOyzLDtN1KbahT21AJt95F1HmPskFt6qa/b5KstaJ8XFUSDLse4iTjmvrabwm0k4lHeIinkx9DKa5lrJPZYyRFKfSD/osJCztMmrKp5pU2TvFwyFBqBAmx9rhhvL7XBbnlLa0ZYVeZZj3074FzFwszkncpA6r6Fj0KQoH7Yzq4t6wrl81OB9pthe4LLCUusfPWtwsyx19hK0Wt0p5tGf3iF3F8vzOKMINnuVinqSWpDY4lTuWairQ5T4eHtnG3ekGGbCe64lnPbqqiXlf3YVtDr54knPnTwBwbjXjIHiWoZzz0nHQSVz73oMDdyL3hxXERwTO7Kf6zc4TuySbLVLbuKoJq4b23E6K2fkdVss5i2USZy77augfRXQ8q3qqNg6i2B0fCU5ossBy7iIKiLjhmMHgBQXS+bcSR5NXz7wMbWArXxOKmNPYDI07SVXfDsCyf4TPrj7Hr/AfJyki//xBUE3t4F88DHK3R/KZRgmodkzV0IIQZYZk+7JIReV2plkSNaJrZ7S03bgs5SeTE7sOCupxydWTr3f40fwLqczar5Wl7FNkNqZyDTG2Q32ULA0veWkcl+f5VMIwydejdIx3FSVmkzrpZHpysT8cq3Ebd2j+cpgY9vI8+np9eQ7dbFxy2aFj+rjynpbpRjlmpW6H79SvB4djd6l4X247eHTcr7Z/PF4ud4yvdOxvlON5szH8nyFMzqeXT1fSlqWHryGT5WvXgryd9pP0T6zd2JsRhmEYhmEYhmEYhmFsFHsYYRiGYRiGYRiGYRjGRrGHEYZhGIZhGIZhGIZhbJSbwhkRgueBzzwNgPZgzs5t56m2l8O482r3AKmXyRkAaFcRuwrtLwAQ2wYk0p7fpV3kMY1RcHWg3srjoN2cdv+5nH3wSQCcuXCCLy63Odc2XMjjhmun1C6wc++dANx+foeq6QZXgjhFfECcJhcB4LJ7ImT3Qeg9bdsM2yxXc9quYn815/wqle1iV7OMMngZOhUOJsN+upi8AetuBwDJY9ph7pU+KiGPIweoRIkIi34cv9/FqTMiPZ3yMo76KfmVMfGS3RTFR1CWB5WhTl5SrMq49JjHH/U5cQwOR3JXlG00j7cu+61EqaMn9qNfwrs96s89ZYjDdttQ7e0PY9dlq4NDjguNQM9aS5cqjJ6IKgztaEpcNkN7ki4FvxxTPSfIw5r8E9m/IX4BKkMa3Dbi4uihaHqkVkDRvkl1WjSE3g/j2UNI08WV0PU1jtTmyrjzShQq8DJ6ARyjHwKXjrk/NGRwHJ2c2lPZDlhzQxTPQOMiQWUYj+5dRGJxE4yZBxWWIQV30TXMFluc/eLpnM6hweHnLa7ux9iLDj4OV/egQsx9LHQVoa1QdfQ5DovljMVqzjLPt6GiD35wDqgKtShzHwfHSanH6M3Q7HLI5Y6Cd6WuY9palFXxGpBG1JU8VZOLZeqDSH3m0DhuAS+SjhWp/80m+4sl/jmMtehaP0hlKcdwLH/ZH7lMpY4lX5/7YOm9c5fyLW6KykU0pxm9Lmm6z86CRdcQ94WYY1DXHZUPNAdz+mVqt/XWCnE6HFNI57mQj2G7v4UGR9s2w3qN6XiGvJ++X7/0VALLCF10PLJIY+Uf/tizuG3xOVydx6NXFYim83s+n8bgCX01xK1ykZmLLLMTKGhq317GeJ3f3+X8R5/J/PT5VPa6x8260RFTx9xZNJ1TAOdTX/aLJm8TkDbS5BhsVR1t8HTODW6TpuppfMD1ed5HHLBVpW3mPjlxDo/uDVGofTl3pvYxmzovoiACO6W88ujzl2EYhmEYxs2AvRlhGIZhGIZhGIZhGMZGsYcRhmEYhmEYhmEYhmFslJtimIZhGIZhGMa1RkReBvwU4IGfVdXXXSn9Vz0v8u5feWbatm8hRty7PkD3YPq87OKh2/j9jz6PP/GiDwDwrnd9C2/9w9t59+rTANzf3c2q/fza4C5FUV2CXukzbI9m/SPW6RN5eokUT4w8dIz+EtnIJVKSvpMLII4QJ5/kHL5w6CiD3Jyfo9qvrVPi8HXl8olPoV6bTusmn+mUyacB86dD02dVD3/Kc8p04OIlPhc61PFWGQJ1qU9rluVPpI6Pd5srpVeu/PnBKdN6XO0nLB9vvpfisep7OI6H01/PdnSp2F3N/qbbTcs//cj7teRyx/jxnfOMq6Ecv8eK7fQ4h0sufVTqx2waT6ztHMmbESLyMhH5uIjcJyKvPYoyGIZhGIZxfBERD/w08HLg+cD3icjzj7ZUhmEYhnF82PibEZOL/0uB+4G7RORtqvr7l9umj467P/d0AKrPfxlelEoiF7okE2t8QFXwkp5st9FzMBGkdZpkclGFNkv4uphkifMsKZy5SBfdII0MKjzSefZ7YT972rzAmfYUf7S/C8D2p5+DiA5ywa2qx4ky96PYLSLsZ/FeyTdEhysCy+CJKiyC52IWS55tPRe6sf7LACCD8C6oEiJUTtAiS8srm+HxktAJBPVjHPM+u/zgqoupbvXkkVQfwcn4lLhIMosos3IpDiVF0JSmm2wnwHY1Ph0TkqCuc2O+y+how7rUz4kbBH1elC466ixQFOBC13Bmsc0fPfxkAGZVT+N7miyEa6qOquoHoZsTpQ+evq+o6xTQGD0huEF4J6JUVU/lA6HIKEU5v7875JPkmZE+S/P64GmDpw1jG6tcFpVqymOr7taOs4iyVbeE6Kiy1FRVWHQNF7K4tAgZSztWFbroaKOnmwjsHAxtrsSvODhFlC4Ks4ngMAJtcEP7iTG1+6m0MuRj7Ccyx+k+Q/CDuDTkPhKB2Fe0OS4XupqHDnboHkox2Plsx269ovaROveJrbrN5U517KNn2dWs+tRHVn019OtS/v2+IqgM+6lzXw069tWqCDcHiWqWcq7NjwLIjiQDFRlj6RhllSnf1H/L+pB/05s+9y1izKkwcy5x7TFvLamXlnwkH5sS/7LPXsfpENL5qfQ7J+k8VvIo8QeG41HqWU/60PSvA6Io1UTmWM49QWc51jW9Cnv7e8N6SLJZP9n3VGJa6OJY6QjsVP2a+DZtV2LruNDV7GfhaxuFVXTEXvj0+ZMAXPjY89m677lDntt1y3azQpFBEtlHz6qrObPYBuBc23DQ+yHfkGOqk3P/J754Bw/cdZIqt8F51VP7njr3y3luowA+Xx9c7t/L0ldDxaqrWeR2e3a5xTJ4ggrnVnMAzrdzzqxmrPJ+QxR2qrD2C4B3Ea9CPWnLuPGaElSGa1Rh0fs1gakTxXjCvAi4T1U/CSAivwy8Erjs/YhhGIZhGNeOo3gzYrj4q2oLlIu/YRiGYRjGpnga8JnJ/P152Roi8moReb+IvP/hM+3h1YZhGIZhPEGO4mHE4774n++XGyucYRiGYRjHgksNFn/Uqyaq+jOq+kJVfeHtp5tLbGIYhmEYxhPhKB5GPO6L/4lqvoFiGYZhGIZxjLgf+PLJ/NOBzx1RWQzDMAzj2HEUDyPs4m8YhmEYxlFzF/BcEXmWiDTA9wJvO+IyGYZhGMaxQVQ3K78SkQr4BPAdwGdJNwPfr6ofvcI2F4CPb6aENyy3Aw8fdSGOGIuBxQAsBmAxAItBqf8zVfWOoy7MzYqIvAL4J6RPe75BVX/iMdLb/Yj1PbAYgMUALAZgMTju9Ycv8X5k4w8j4Ald/N+vqi/cSOFuUCwGFgOwGIDFACwGYDE47vU/KizuFgOwGIDFACwGYDE47vWHLz0GG/+0J4Cq/gbwG0exb8MwDMMwDMMwDMMwjpajcEYYhmEYhmEYhmEYhnGMuVkeRvzMURfgBsBiYDEAiwFYDMBiABaD417/o8LibjEAiwFYDMBiABaD415/+BJjcCTOCMMwDMMwDMMwDMMwji83y5sRhmEYhmEYhmEYhmHcItjDCMMwDMMwDMMwDMMwNsoN/zBCRF4mIh8XkftE5LVHXZ5NISKfFpF7RORDIvL+vOy0iPyWiNyb/9521OW8lojIG0TkQRH5yGTZJessiX+a28WHReTrjq7k147LxODvishnc1v4UP40bln3t3IMPi4i//XRlPraISJfLiLvFJGPichHReRv5OXHph1cIQbHqR3MReR9InJ3jsH/kZc/S0Tem9vBm0Wkyctnef6+vP7Ooyz/teAKMfh5EfnUpB28IC+/5frCjYbdj9j9yHG5DoHdj9j9iN2PgN2PwAbuR1T1hv0HeOA/A88GGuBu4PlHXa4N1f3TwO2Hlv1D4LV5+rXAPzjqcl7jOn8b8HXARx6rzsArgH8HCPCNwHuPuvzXMQZ/F/ixS6R9fu4TM+BZua/4o67Dl1j/pwJfl6f3gE/keh6bdnCFGByndiDAbp6ugffm4/srwPfm5a8H/lqe/p+A1+fp7wXefNR1uI4x+Hngey6R/pbrCzfSP7sfsfuR43QdukIMjtN1yO5H7H7E7keuHINrcj9yo78Z8SLgPlX9pKq2wC8DrzziMh0lrwTemKffCHzXEZblmqOqvwOcObT4cnV+JfALmngPcEpEnrqZkl4/LhODy/FK4JdVdaWqnwLuI/WZmxZVfUBVP5CnLwAfA57GMWoHV4jB5bgV24Gq6sU8W+d/Cvxp4C15+eF2UNrHW4DvEBHZUHGvC1eIweW45frCDYbdj6xj9yO38HUI7H7E7kfsfgTsfgSu//3Ijf4w4mnAZybz93PlTnArocBvish/EpFX52VPUdUHIJ0ggCcfWek2x+XqfNzaxmvyq05vmLwOe0vHIL/a9rWkJ7DHsh0cigEco3YgIl5EPgQ8CPwW6ReWR1S1z0mm9RxikNefA5602RJfew7HQFVLO/iJ3A7+sYjM8rJbsh3cQBzn+Nr9SOJYXocuwbG5DhXsfsTuR+x+5Prdj9zoDyMu9STpuHyL9JtV9euAlwM/LCLfdtQFusE4Tm3jnwPPAV4APAD8X3n5LRsDEdkFfg34UVU9f6Wkl1h2q8bgWLUDVQ2q+gLg6aRfVp53qWT577GIgYh8NfC3gK8EvgE4DfyvOfktGYMbiOMcX7sfuTLHqW0cq+sQ2P0I2P2I3Y9c3/uRG/1hxP3Al0/mnw587ojKslFU9XP574PAr5Ma/xfKay7574NHV8KNcbk6H5u2oapfyCeBCPzfjK+83ZIxEJGadNF7k6q+NS8+Vu3gUjE4bu2goKqPAP8fadzhKRGp8qppPYcY5PUnufrXi294JjF4WX5tVlV1Bfwcx6Qd3AAc2/ja/cjAsboOXYrjdh2y+xG7H5li9yPX537kRn8YcRfw3GwsbUgikLcdcZmuOyKyIyJ7ZRr4TuAjpLq/Kid7FfCvjqaEG+VydX4b8N9nY+s3AufKa3O3GofGWX03qS1AisH3ZnPvs4DnAu/bdPmuJXlc3b8APqaqPzlZdWzaweVicMzawR0icipPbwEvIY1VfSfwPTnZ4XZQ2sf3AO9Q1Zv6l4jLxOAPJjfBQhqjOm0Ht1RfuMGw+xG7Hzk216HLccyuQ3Y/Yvcjdj/CBu5H9AawdF7pH8nI+QnS+JwfP+rybKjOzybZaO8GPlrqTRpz9NvAvfnv6aMu6zWu9y+RXvfqSE/VfuhydSa9AvTTuV3cA7zwqMt/HWPwi7mOH84d/KmT9D+eY/Bx4OVHXf5rUP9vIb3K9WHgQ/nfK45TO7hCDI5TO/ga4IO5rh8B/ve8/NmkG5v7gF8FZnn5PM/fl9c/+6jrcB1j8I7cDj4C/D+Mhutbri/caP/sfsTuR47LdegKMThO1yG7H7H7EbsfuXIMrsn9iOSNDMMwDMMwDMMwDMMwNsKNPkzDMAzDMAzDMAzDMIxbDHsYYRiGYRiGYRiGYRjGRrGHEYZhGIZhGIZhGIZhbBR7GGEYhmEYhmEYhmEYxkaxhxGGYRiGYRiGYRiGYWwUexhhGMcIEQki8qHJvzuPukyGYRiGYRw9k3uEj4rI3SLyN0Xkuv2/gojcKSIf+RLz+NuH5v/jl1aqK+7rThH5/uuVv2EcR+zTnoZxjBCRi6q6e4X1lar2myyTYRiGYRhHz/QeQUSeDPxL4N2q+neu0/7uBP6Nqn71Vab3qhoOLbvifc21RES+HfgxVf2zm9ifYRwH7M0IwzjmiMj/ICK/KiL/GvhNEdkVkd8WkQ+IyD0i8sqc7k4R+QMR+VkR+YiIvElEXiIi7xaRe0XkRTndjoi8QUTuEpEPTrb/KhF5X/7V5cMi8twjrLZhGIZhGJdBVR8EXg28RhJeRP5RvrZ/WET+SkkrIv9Lvl+4W0Rel5e9QETek9P+uojclpd/fU73e8APT/K4ZP4i8u0i8k4R+ZfAPdMy5n1t5fuKN+VlFyfbvUtEfkVEPiEirxORH8j3IfeIyHNyujtE5Nfyfu8SkW/Oy//k5C3SD4rIHvA64Fvzsv/5Mcr8O7nevy8ir7+eb5gYxs1MddQFMAxjo2yJyIfy9KdU9bvz9DcBX6OqZ0SkAr5bVc+LyO3Ae0TkbTndVwB/nnSDchfw/cC3AH8O+NvAdwE/DrxDVX9QRE4B7xOR/wD8VeCnVPVNItIA/vpX1zAMwzCMJ4KqfjL/T/STgVcC51T1G0RkBrxbRH4T+ErStf+/UtUDETmdN/8F4EdU9V0i8veAvwP8KPBzk+X/aLK7H7pM/gAvAr5aVT91qHyvFZHXqOoLLlOFPwE8DzgDfBL4WVV9kYj8DeBHcnl+CvjHqvq7IvIM4O15mx8DflhV3y0iu8ASeC2TNyNE5NWPUebnA38I/HvgvwHecjVxN4zjhD2MMIzjxeIyF+3fUtUzeVqAvy8i3wZE4GnAU/K6T6nqPQAi8lHgt1VVReQe4M6c5juBPyciP5bn58AzgN8DflxEng68VVXvvcZ1MwzDMAzj2iL573cCXyMi35PnTwLPBV4C/JyqHgDkHzVOAqdU9V057RuBX73E8l8EXv4Y+bfA+w4/iLhK7lLVBwBE5D8D5UHBPcCfytMvAZ4vUqrJifwWxLuBn8xvXLxVVe+fpCk8Vpk/mff9S6QfbuxhhGEcwh5GGIYBsD+Z/gHgDuDrVbUTkU+THigArCbp4mQ+Mp5PBPhvVfXjh/bxMRF5L/BngLeLyP+oqu+4hnUwDMMwDOMaISLPBgLwIOna/iOq+vZDaV4GXK2ATq6Q9nL5fzvr9yiPh6u5Z3HAN6nq4tC2rxORfwu8gvSG6EseZ5kP19MkfYZxCWz8kmEYhzkJPJgfRPwp4JmPc/u3Az8i+ScEEfna/PfZwCdV9Z8CbwO+5hqW2TAMwzCMa4SI3AG8Hvhnmmz3bwf+mojUef0fF5Ed0tsGPygi23n5aVU9B5wVkW/N2f0l4F2q+ghwTkS+JS//gckuL5f/Y9GVbZ4gvwm8psyIyAvy3+eo6j2q+g+A95OGo1wA9q6yzC8SkWflYS5/EfjdL6GMhnHLYm9GGIZxmDcB/1pE3g98CPiDx7n9/wn8E+DD+YHEp4E/S7oY/3ci0gGfB/7eNSuxYRiGYRhfKsUrVQM9aRjFT+Z1P0sajvmBfG1/CPguVf33+X/g3y8iLfAbJIfUq4DX54cUnwT+cs7nLwNvEJED0v/Mc6X8r6LMP0O63/iAqv7AY6Z+NH8d+GkR+TDp/4t+h+S4+tH8g0wAfh/4d6Q3KnoRuRv4eZJv4nJl/j2S8PK/zHn++hMom2Hc8tinPQ3DMAzDMAzDMK4BYp8ANYyrxoZpGIZhGIZhGIZhGIaxUezNCMMwDMMwDMMwDMMwNoq9GWEYhmEYhmEYhmEYxkaxhxGGYRiGYRiGYRiGYWwUexhhGIZhGIZhGIZhGMZGsYcRhmEYhmEYhmEYhmFsFHsYYRiGYRiGYRiGYRjGRvn/AQuSXvZLqyg3AAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] @@ -431,6 +372,149 @@ "])" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Parse nvlog" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DLLL {\"timestamp\": \"1613260158.487929\", \"datetime\": \"2021-02-13 23:49:18.487929\", \"elapsedtime\": \"24111.014423\", \"type\": \"LOG\", \"step\": [790, 1], \"data\": {\"glob_iter/iters_per_epoch\": \"5708/13\"}}\r\n", + "DLLL {\"timestamp\": \"1613260159.993744\", \"datetime\": \"2021-02-13 23:49:19.993744\", \"elapsedtime\": \"24112.520238\", \"type\": \"LOG\", \"step\": [790, 1], \"data\": {\"train_loss\": 0.3499102294445038}}\r\n", + "DLLL {\"timestamp\": \"1613260161.941808\", \"datetime\": \"2021-02-13 23:49:21.941808\", \"elapsedtime\": \"24114.468302\", \"type\": \"LOG\", \"step\": [790, 1], \"data\": {\"train_items_per_sec\": 4538.938052832199}}\r\n", + "DLLL {\"timestamp\": \"1613260161.941942\", \"datetime\": \"2021-02-13 23:49:21.941942\", \"elapsedtime\": \"24114.468436\", \"type\": \"LOG\", \"step\": [790, 1], \"data\": {\"train_iter_time\": 3.453891597004258}}\r\n", + "DLLL {\"timestamp\": \"1613260161.951703\", \"datetime\": \"2021-02-13 23:49:21.951703\", \"elapsedtime\": \"24114.478197\", \"type\": \"LOG\", \"step\": [790, 2], \"data\": {\"glob_iter/iters_per_epoch\": \"5709/13\"}}\r\n", + "DLLL {\"timestamp\": \"1613260163.523834\", \"datetime\": \"2021-02-13 23:49:23.523834\", \"elapsedtime\": \"24116.050328\", \"type\": \"LOG\", \"step\": [790, 2], \"data\": {\"train_loss\": 0.3621940016746521}}\r\n", + "DLLL {\"timestamp\": \"1613260165.566278\", \"datetime\": \"2021-02-13 23:49:25.566278\", \"elapsedtime\": \"24118.092772\", \"type\": \"LOG\", \"step\": [790, 2], \"data\": {\"train_items_per_sec\": 4703.442347979841}}\r\n", + "DLLL {\"timestamp\": \"1613260165.566416\", \"datetime\": \"2021-02-13 23:49:25.566416\", \"elapsedtime\": \"24118.09291\", \"type\": \"LOG\", \"step\": [790, 2], \"data\": {\"train_iter_time\": 3.6145866669976385}}\r\n", + "DLLL {\"timestamp\": \"1613260165.573997\", \"datetime\": \"2021-02-13 23:49:25.573997\", \"elapsedtime\": \"24118.100491\", \"type\": \"LOG\", \"step\": [790, 3], \"data\": {\"glob_iter/iters_per_epoch\": \"5710/13\"}}\r\n", + "DLLL {\"timestamp\": \"1613260167.24385\", \"datetime\": \"2021-02-13 23:49:27.243850\", \"elapsedtime\": \"24119.770344\", \"type\": \"LOG\", \"step\": [790, 3], \"data\": {\"train_loss\": 0.34290337562561035}}\r\n", + "DLLL {\"timestamp\": \"1613260169.399331\", \"datetime\": \"2021-02-13 23:49:29.399331\", \"elapsedtime\": \"24121.925825\", \"type\": \"LOG\", \"step\": [790, 3], \"data\": {\"train_items_per_sec\": 4490.312452439713}}\r\n", + "DLLL {\"timestamp\": \"1613260169.399471\", \"datetime\": \"2021-02-13 23:49:29.399471\", \"elapsedtime\": \"24121.925965\", \"type\": \"LOG\", \"step\": [790, 3], \"data\": {\"train_iter_time\": 3.825346271987655}}\r\n", + "DLLL {\"timestamp\": \"1613260169.407979\", \"datetime\": \"2021-02-13 23:49:29.407979\", \"elapsedtime\": \"24121.934473\", \"type\": \"LOG\", \"step\": [790, 4], \"data\": {\"glob_iter/iters_per_epoch\": \"5711/13\"}}\r\n", + "DLLL {\"timestamp\": \"1613260171.037161\", \"datetime\": \"2021-02-13 23:49:31.037161\", \"elapsedtime\": \"24123.563655\", \"type\": \"LOG\", \"step\": [790, 4], \"data\": {\"train_loss\": 0.40105947852134705}}\r\n", + "DLLL {\"timestamp\": \"1613260173.156379\", \"datetime\": \"2021-02-13 23:49:33.156379\", \"elapsedtime\": \"24125.682873\", \"type\": \"LOG\", \"step\": [790, 4], \"data\": {\"train_items_per_sec\": 5208.0738733658145}}\r\n", + "DLLL {\"timestamp\": \"1613260173.156513\", \"datetime\": \"2021-02-13 23:49:33.156513\", \"elapsedtime\": \"24125.683007\", \"type\": \"LOG\", \"step\": [790, 4], \"data\": {\"train_iter_time\": 3.7484107320051407}}\r\n", + "DLLL {\"timestamp\": \"1613260173.168099\", \"datetime\": \"2021-02-13 23:49:33.168099\", \"elapsedtime\": \"24125.694593\", \"type\": \"LOG\", \"step\": [790, 5], \"data\": {\"glob_iter/iters_per_epoch\": \"5712/13\"}}\r\n", + "DLLL {\"timestamp\": \"1613260174.882324\", \"datetime\": \"2021-02-13 23:49:34.882324\", \"elapsedtime\": \"24127.408818\", \"type\": \"LOG\", \"step\": [790, 5], \"data\": {\"train_loss\": 0.3285461664199829}}\r\n", + "DLLL {\"timestamp\": \"1613260177.109261\", \"datetime\": \"2021-02-13 23:49:37.109261\", \"elapsedtime\": \"24129.635755\", \"type\": \"LOG\", \"step\": [790, 5], \"data\": {\"train_items_per_sec\": 4287.300545595056}}\r\n", + "DLLL {\"timestamp\": \"1613260177.109395\", \"datetime\": \"2021-02-13 23:49:37.109395\", \"elapsedtime\": \"24129.635889\", \"type\": \"LOG\", \"step\": [790, 5], \"data\": {\"train_iter_time\": 3.94117459699919}}\r\n", + "DLLL {\"timestamp\": \"1613260177.120371\", \"datetime\": \"2021-02-13 23:49:37.120371\", \"elapsedtime\": \"24129.646865\", \"type\": \"LOG\", \"step\": [790, 6], \"data\": {\"glob_iter/iters_per_epoch\": \"5713/13\"}}\r\n", + "DLLL {\"timestamp\": \"1613260178.652027\", \"datetime\": \"2021-02-13 23:49:38.652027\", \"elapsedtime\": \"24131.178521\", \"type\": \"LOG\", \"step\": [790, 6], \"data\": {\"train_loss\": 0.36544039845466614}}\r\n", + "DLLL {\"timestamp\": \"1613260180.626034\", \"datetime\": \"2021-02-13 23:49:40.626034\", \"elapsedtime\": \"24133.152528\", \"type\": \"LOG\", \"step\": [790, 6], \"data\": {\"train_items_per_sec\": 4819.044510659347}}\r\n", + "DLLL {\"timestamp\": \"1613260180.626165\", \"datetime\": \"2021-02-13 23:49:40.626165\", \"elapsedtime\": \"24133.152659\", \"type\": \"LOG\", \"step\": [790, 6], \"data\": {\"train_iter_time\": 3.5056741979933577}}\r\n", + "DLLL {\"timestamp\": \"1613260180.6374\", \"datetime\": \"2021-02-13 23:49:40.637400\", \"elapsedtime\": \"24133.163894\", \"type\": \"LOG\", \"step\": [790, 7], \"data\": {\"glob_iter/iters_per_epoch\": \"5714/13\"}}\r\n", + "DLLL {\"timestamp\": \"1613260182.290356\", \"datetime\": \"2021-02-13 23:49:42.290356\", \"elapsedtime\": \"24134.81685\", \"type\": \"LOG\", \"step\": [790, 7], \"data\": {\"train_loss\": 0.3259407877922058}}\r\n", + "DLLL {\"timestamp\": \"1613260184.44935\", \"datetime\": \"2021-02-13 23:49:44.449350\", \"elapsedtime\": \"24136.975844\", \"type\": \"LOG\", \"step\": [790, 7], \"data\": {\"train_items_per_sec\": 4270.241330126292}}\r\n", + "DLLL {\"timestamp\": \"1613260184.449486\", \"datetime\": \"2021-02-13 23:49:44.449486\", \"elapsedtime\": \"24136.97598\", \"type\": \"LOG\", \"step\": [790, 7], \"data\": {\"train_iter_time\": 3.8119625429972075}}\r\n", + "DLLL {\"timestamp\": \"1613260184.459236\", \"datetime\": \"2021-02-13 23:49:44.459236\", \"elapsedtime\": \"24136.98573\", \"type\": \"LOG\", \"step\": [790, 8], \"data\": {\"glob_iter/iters_per_epoch\": \"5715/13\"}}\r\n", + "DLLL {\"timestamp\": \"1613260185.95168\", \"datetime\": \"2021-02-13 23:49:45.951680\", \"elapsedtime\": \"24138.478174\", \"type\": \"LOG\", \"step\": [790, 8], \"data\": {\"train_loss\": 0.36399826407432556}}\r\n", + "DLLL {\"timestamp\": \"1613260187.88434\", \"datetime\": \"2021-02-13 23:49:47.884340\", \"elapsedtime\": \"24140.410834\", \"type\": \"LOG\", \"step\": [790, 8], \"data\": {\"train_items_per_sec\": 4748.453597589112}}\r\n", + "DLLL {\"timestamp\": \"1613260187.884482\", \"datetime\": \"2021-02-13 23:49:47.884482\", \"elapsedtime\": \"24140.410976\", \"type\": \"LOG\", \"step\": [790, 8], \"data\": {\"train_iter_time\": 3.4251150749914814}}\r\n", + "DLLL {\"timestamp\": \"1613260187.892197\", \"datetime\": \"2021-02-13 23:49:47.892197\", \"elapsedtime\": \"24140.418691\", \"type\": \"LOG\", \"step\": [790, 9], \"data\": {\"glob_iter/iters_per_epoch\": \"5716/13\"}}\r\n", + "DLLL {\"timestamp\": \"1613260189.549036\", \"datetime\": \"2021-02-13 23:49:49.549036\", \"elapsedtime\": \"24142.07553\", \"type\": \"LOG\", \"step\": [790, 9], \"data\": {\"train_loss\": 0.3610873818397522}}\r\n", + "DLLL {\"timestamp\": \"1613260191.700089\", \"datetime\": \"2021-02-13 23:49:51.700089\", \"elapsedtime\": \"24144.226583\", \"type\": \"LOG\", \"step\": [790, 9], \"data\": {\"train_items_per_sec\": 4673.174224536043}}\r\n", + "DLLL {\"timestamp\": \"1613260191.700224\", \"datetime\": \"2021-02-13 23:49:51.700224\", \"elapsedtime\": \"24144.226718\", \"type\": \"LOG\", \"step\": [790, 9], \"data\": {\"train_iter_time\": 3.8079042520112125}}\r\n", + "DLLL {\"timestamp\": \"1613260191.711165\", \"datetime\": \"2021-02-13 23:49:51.711165\", \"elapsedtime\": \"24144.237659\", \"type\": \"LOG\", \"step\": [790, 10], \"data\": {\"glob_iter/iters_per_epoch\": \"5717/13\"}}\r\n", + "DLLL {\"timestamp\": \"1613260193.472417\", \"datetime\": \"2021-02-13 23:49:53.472417\", \"elapsedtime\": \"24145.998911\", \"type\": \"LOG\", \"step\": [790, 10], \"data\": {\"train_loss\": 0.39527997374534607}}\r\n", + "DLLL {\"timestamp\": \"1613260195.784164\", \"datetime\": \"2021-02-13 23:49:55.784164\", \"elapsedtime\": \"24148.310658\", \"type\": \"LOG\", \"step\": [790, 10], \"data\": {\"train_items_per_sec\": 5025.766146731682}}\r\n", + "DLLL {\"timestamp\": \"1613260195.786309\", \"datetime\": \"2021-02-13 23:49:55.786309\", \"elapsedtime\": \"24148.312803\", \"type\": \"LOG\", \"step\": [790, 10], \"data\": {\"train_iter_time\": 4.07301084100618}}\r\n", + "DLLL {\"timestamp\": \"1613260195.7957\", \"datetime\": \"2021-02-13 23:49:55.795700\", \"elapsedtime\": \"24148.322194\", \"type\": \"LOG\", \"step\": [790, 11], \"data\": {\"glob_iter/iters_per_epoch\": \"5718/13\"}}\r\n", + "DLLL {\"timestamp\": \"1613260197.454689\", \"datetime\": \"2021-02-13 23:49:57.454689\", \"elapsedtime\": \"24149.981183\", \"type\": \"LOG\", \"step\": [790, 11], \"data\": {\"train_loss\": 0.3523614704608917}}\r\n", + "DLLL {\"timestamp\": \"1613260199.602739\", \"datetime\": \"2021-02-13 23:49:59.602739\", \"elapsedtime\": \"24152.129233\", \"type\": \"LOG\", \"step\": [790, 11], \"data\": {\"train_items_per_sec\": 4574.146695724187}}\r\n", + "DLLL {\"timestamp\": \"1613260199.602874\", \"datetime\": \"2021-02-13 23:49:59.602874\", \"elapsedtime\": \"24152.129368\", \"type\": \"LOG\", \"step\": [790, 11], \"data\": {\"train_iter_time\": 3.807048867995036}}\r\n", + "DLLL {\"timestamp\": \"1613260199.612983\", \"datetime\": \"2021-02-13 23:49:59.612983\", \"elapsedtime\": \"24152.139477\", \"type\": \"LOG\", \"step\": [790, 12], \"data\": {\"glob_iter/iters_per_epoch\": \"5719/13\"}}\r\n", + "DLLL {\"timestamp\": \"1613260201.371872\", \"datetime\": \"2021-02-13 23:50:01.371872\", \"elapsedtime\": \"24153.898366\", \"type\": \"LOG\", \"step\": [790, 12], \"data\": {\"train_loss\": 0.3457852602005005}}\r\n", + "DLLL {\"timestamp\": \"1613260203.641127\", \"datetime\": \"2021-02-13 23:50:03.641127\", \"elapsedtime\": \"24156.167621\", \"type\": \"LOG\", \"step\": [790, 12], \"data\": {\"train_items_per_sec\": 4514.223411973792}}\r\n", + "DLLL {\"timestamp\": \"1613260203.64126\", \"datetime\": \"2021-02-13 23:50:03.641260\", \"elapsedtime\": \"24156.167754\", \"type\": \"LOG\", \"step\": [790, 12], \"data\": {\"train_iter_time\": 4.028156858999864}}\r\n", + "DLLL {\"timestamp\": \"1613260203.679966\", \"datetime\": \"2021-02-13 23:50:03.679966\", \"elapsedtime\": \"24156.20646\", \"type\": \"LOG\", \"step\": [790], \"data\": {\"train_items_per_sec\": 4642.715448482791}}\r\n", + "DLLL {\"timestamp\": \"1613260203.680104\", \"datetime\": \"2021-02-13 23:50:03.680104\", \"elapsedtime\": \"24156.206598\", \"type\": \"LOG\", \"step\": [790], \"data\": {\"train_loss\": 0.3457852602005005}}\r\n", + "DLLL {\"timestamp\": \"1613260203.680167\", \"datetime\": \"2021-02-13 23:50:03.680167\", \"elapsedtime\": \"24156.206661\", \"type\": \"LOG\", \"step\": [790], \"data\": {\"train_epoch_time\": 49.26070692999929}}\r\n", + "DLLL {\"timestamp\": \"1613260205.299704\", \"datetime\": \"2021-02-13 23:50:05.299704\", \"elapsedtime\": \"24157.826198\", \"type\": \"LOG\", \"step\": [790, 5720, 0], \"data\": {\"val_items_per_sec\": 13869.564672304557}}\r\n", + "DLLL {\"timestamp\": \"1613260206.703353\", \"datetime\": \"2021-02-13 23:50:06.703353\", \"elapsedtime\": \"24159.229847\", \"type\": \"LOG\", \"step\": [790, 5720, 1], \"data\": {\"val_items_per_sec\": 13407.354885992667}}\r\n", + "DLLL {\"timestamp\": \"1613260207.938711\", \"datetime\": \"2021-02-13 23:50:07.938711\", \"elapsedtime\": \"24160.465205\", \"type\": \"LOG\", \"step\": [790, 5720, 2], \"data\": {\"val_items_per_sec\": 14171.624377123939}}\r\n", + "DLLL {\"timestamp\": \"1613260208.929501\", \"datetime\": \"2021-02-13 23:50:08.929501\", \"elapsedtime\": \"24161.455995\", \"type\": \"LOG\", \"step\": [790, 5720, 3], \"data\": {\"val_items_per_sec\": 2154.5592796913575}}\r\n", + "DLLL {\"timestamp\": \"1613260208.966335\", \"datetime\": \"2021-02-13 23:50:08.966335\", \"elapsedtime\": \"24161.492829\", \"type\": \"LOG\", \"step\": [790], \"data\": {\"val_loss\": 0.33910156041383743}}\r\n", + "DLLL {\"timestamp\": \"1613260208.966575\", \"datetime\": \"2021-02-13 23:50:08.966575\", \"elapsedtime\": \"24161.493069\", \"type\": \"LOG\", \"step\": [790], \"data\": {\"val_items_per_sec\": 10900.77580377813}}\r\n", + "DLLL {\"timestamp\": \"1613260209.103941\", \"datetime\": \"2021-02-13 23:50:09.103941\", \"elapsedtime\": \"24161.630435\", \"type\": \"LOG\", \"step\": [791, 0], \"data\": {\"glob_iter/iters_per_epoch\": \"5720/13\"}}\r\n", + "DLLL {\"timestamp\": \"1613260210.771315\", \"datetime\": \"2021-02-13 23:50:10.771315\", \"elapsedtime\": \"24163.297809\", \"type\": \"LOG\", \"step\": [791, 0], \"data\": {\"train_loss\": 0.3610868752002716}}\r\n", + "DLLL {\"timestamp\": \"1613260212.833175\", \"datetime\": \"2021-02-13 23:50:12.833175\", \"elapsedtime\": \"24165.359669\", \"type\": \"LOG\", \"step\": [791, 0], \"data\": {\"train_items_per_sec\": 4533.820984057406}}\r\n", + "DLLL {\"timestamp\": \"1613260212.833315\", \"datetime\": \"2021-02-13 23:50:12.833315\", \"elapsedtime\": \"24165.359809\", \"type\": \"LOG\", \"step\": [791, 0], \"data\": {\"train_iter_time\": 3.729304720996879}}\r\n", + "DLLL {\"timestamp\": \"1613260212.843412\", \"datetime\": \"2021-02-13 23:50:12.843412\", \"elapsedtime\": \"24165.369906\", \"type\": \"LOG\", \"step\": [791, 1], \"data\": {\"glob_iter/iters_per_epoch\": \"5721/13\"}}\r\n", + "DLLL {\"timestamp\": \"1613260214.550588\", \"datetime\": \"2021-02-13 23:50:14.550588\", \"elapsedtime\": \"24167.077082\", \"type\": \"LOG\", \"step\": [791, 1], \"data\": {\"train_loss\": 0.3312675952911377}}\r\n", + "DLLL {\"timestamp\": \"1613260216.790641\", \"datetime\": \"2021-02-13 23:50:16.790641\", \"elapsedtime\": \"24169.317135\", \"type\": \"LOG\", \"step\": [791, 1], \"data\": {\"train_items_per_sec\": 4325.5516625175305}}\r\n", + "DLLL {\"timestamp\": \"1613260216.790779\", \"datetime\": \"2021-02-13 23:50:16.790779\", \"elapsedtime\": \"24169.317273\", \"type\": \"LOG\", \"step\": [791, 1], \"data\": {\"train_iter_time\": 3.947242185997311}}\r\n", + "DLLL {\"timestamp\": \"1613260216.800489\", \"datetime\": \"2021-02-13 23:50:16.800489\", \"elapsedtime\": \"24169.326983\", \"type\": \"LOG\", \"step\": [791, 2], \"data\": {\"glob_iter/iters_per_epoch\": \"5722/13\"}}\r\n", + "DLLL {\"timestamp\": \"1613260218.557104\", \"datetime\": \"2021-02-13 23:50:18.557104\", \"elapsedtime\": \"24171.083598\", \"type\": \"LOG\", \"step\": [791, 2], \"data\": {\"train_loss\": 0.3222716450691223}}\r\n", + "DLLL {\"timestamp\": \"1613260220.868867\", \"datetime\": \"2021-02-13 23:50:20.868867\", \"elapsedtime\": \"24173.395361\", \"type\": \"LOG\", \"step\": [791, 2], \"data\": {\"train_items_per_sec\": 4254.261188867131}}\r\n", + "DLLL {\"timestamp\": \"1613260220.868998\", \"datetime\": \"2021-02-13 23:50:20.868998\", \"elapsedtime\": \"24173.395492\", \"type\": \"LOG\", \"step\": [791, 2], \"data\": {\"train_iter_time\": 4.068391485998291}}\r\n", + "DLLL {\"timestamp\": \"1613260220.879207\", \"datetime\": \"2021-02-13 23:50:20.879207\", \"elapsedtime\": \"24173.405701\", \"type\": \"LOG\", \"step\": [791, 3], \"data\": {\"glob_iter/iters_per_epoch\": \"5723/13\"}}\r\n", + "DLLL {\"timestamp\": \"1613260222.533327\", \"datetime\": \"2021-02-13 23:50:22.533327\", \"elapsedtime\": \"24175.059821\", \"type\": \"LOG\", \"step\": [791, 3], \"data\": {\"train_loss\": 0.3352973461151123}}\r\n", + "DLLL {\"timestamp\": \"1613260224.683802\", \"datetime\": \"2021-02-13 23:50:24.683802\", \"elapsedtime\": \"24177.210296\", \"type\": \"LOG\", \"step\": [791, 3], \"data\": {\"train_items_per_sec\": 4236.181362637959}}\r\n", + "DLLL {\"timestamp\": \"1613260224.683935\", \"datetime\": \"2021-02-13 23:50:24.683935\", \"elapsedtime\": \"24177.210429\", \"type\": \"LOG\", \"step\": [791, 3], \"data\": {\"train_iter_time\": 3.8046057570027187}}\r\n", + "DLLL {\"timestamp\": \"1613260224.695678\", \"datetime\": \"2021-02-13 23:50:24.695678\", \"elapsedtime\": \"24177.222172\", \"type\": \"LOG\", \"step\": [791, 4], \"data\": {\"glob_iter/iters_per_epoch\": \"5724/13\"}}\r\n", + "DLLL {\"timestamp\": \"1613260226.314902\", \"datetime\": \"2021-02-13 23:50:26.314902\", \"elapsedtime\": \"24178.841396\", \"type\": \"LOG\", \"step\": [791, 4], \"data\": {\"train_loss\": 0.38849177956581116}}\r\n", + "DLLL {\"timestamp\": \"1613260228.414953\", \"datetime\": \"2021-02-13 23:50:28.414953\", \"elapsedtime\": \"24180.941447\", \"type\": \"LOG\", \"step\": [791, 4], \"data\": {\"train_items_per_sec\": 4996.925925311962}}\r\n", + "DLLL {\"timestamp\": \"1613260228.415085\", \"datetime\": \"2021-02-13 23:50:28.415085\", \"elapsedtime\": \"24180.941579\", \"type\": \"LOG\", \"step\": [791, 4], \"data\": {\"train_iter_time\": 3.7192866730038077}}\r\n", + "DLLL {\"timestamp\": \"1613260228.425829\", \"datetime\": \"2021-02-13 23:50:28.425829\", \"elapsedtime\": \"24180.952323\", \"type\": \"LOG\", \"step\": [791, 5], \"data\": {\"glob_iter/iters_per_epoch\": \"5725/13\"}}\r\n", + "DLLL {\"timestamp\": \"1613260230.076549\", \"datetime\": \"2021-02-13 23:50:30.076549\", \"elapsedtime\": \"24182.603043\", \"type\": \"LOG\", \"step\": [791, 5], \"data\": {\"train_loss\": 0.31019118428230286}}\r\n", + "DLLL {\"timestamp\": \"1613260232.249928\", \"datetime\": \"2021-02-13 23:50:32.249928\", \"elapsedtime\": \"24184.776422\", \"type\": \"LOG\", \"step\": [791, 5], \"data\": {\"train_items_per_sec\": 4035.7100851543955}}\r\n", + "DLLL {\"timestamp\": \"1613260232.250069\", \"datetime\": \"2021-02-13 23:50:32.250069\", \"elapsedtime\": \"24184.776563\", \"type\": \"LOG\", \"step\": [791, 5], \"data\": {\"train_iter_time\": 3.8241101750027156}}\r\n", + "DLLL {\"timestamp\": \"1613260232.262465\", \"datetime\": \"2021-02-13 23:50:32.262465\", \"elapsedtime\": \"24184.788959\", \"type\": \"LOG\", \"step\": [791, 6], \"data\": {\"glob_iter/iters_per_epoch\": \"5726/13\"}}\r\n", + "DLLL {\"timestamp\": \"1613260233.967236\", \"datetime\": \"2021-02-13 23:50:33.967236\", \"elapsedtime\": \"24186.49373\", \"type\": \"LOG\", \"step\": [791, 6], \"data\": {\"train_loss\": 0.38987359404563904}}\r\n", + "DLLL {\"timestamp\": \"1613260236.196505\", \"datetime\": \"2021-02-13 23:50:36.196505\", \"elapsedtime\": \"24188.722999\", \"type\": \"LOG\", \"step\": [791, 6], \"data\": {\"train_items_per_sec\": 5072.119490693871}}\r\n", + "DLLL {\"timestamp\": \"1613260236.196642\", \"datetime\": \"2021-02-13 23:50:36.196642\", \"elapsedtime\": \"24188.723136\", \"type\": \"LOG\", \"step\": [791, 6], \"data\": {\"train_iter_time\": 3.9340555829985533}}\r\n", + "DLLL {\"timestamp\": \"1613260236.208422\", \"datetime\": \"2021-02-13 23:50:36.208422\", \"elapsedtime\": \"24188.734916\", \"type\": \"LOG\", \"step\": [791, 7], \"data\": {\"glob_iter/iters_per_epoch\": \"5727/13\"}}\r\n", + "DLLL {\"timestamp\": \"1613260237.932468\", \"datetime\": \"2021-02-13 23:50:37.932468\", \"elapsedtime\": \"24190.458962\", \"type\": \"LOG\", \"step\": [791, 7], \"data\": {\"train_loss\": 0.3397759199142456}}\r\n", + "DLLL {\"timestamp\": \"1613260240.182758\", \"datetime\": \"2021-02-13 23:50:40.182758\", \"elapsedtime\": \"24192.709252\", \"type\": \"LOG\", \"step\": [791, 7], \"data\": {\"train_items_per_sec\": 4558.987183719765}}\r\n", + "DLLL {\"timestamp\": \"1613260240.182899\", \"datetime\": \"2021-02-13 23:50:40.182899\", \"elapsedtime\": \"24192.709393\", \"type\": \"LOG\", \"step\": [791, 7], \"data\": {\"train_iter_time\": 3.974347650000709}}\r\n", + "DLLL {\"timestamp\": \"1613260240.194154\", \"datetime\": \"2021-02-13 23:50:40.194154\", \"elapsedtime\": \"24192.720648\", \"type\": \"LOG\", \"step\": [791, 8], \"data\": {\"glob_iter/iters_per_epoch\": \"5728/13\"}}\r\n", + "DLLL {\"timestamp\": \"1613260241.853646\", \"datetime\": \"2021-02-13 23:50:41.853646\", \"elapsedtime\": \"24194.38014\", \"type\": \"LOG\", \"step\": [791, 8], \"data\": {\"train_loss\": 0.3450845777988434}}\r\n", + "DLLL {\"timestamp\": \"1613260244.01321\", \"datetime\": \"2021-02-13 23:50:44.013210\", \"elapsedtime\": \"24196.539704\", \"type\": \"LOG\", \"step\": [791, 8], \"data\": {\"train_items_per_sec\": 4461.5603411554175}}\r\n", + "DLLL {\"timestamp\": \"1613260244.013346\", \"datetime\": \"2021-02-13 23:50:44.013346\", \"elapsedtime\": \"24196.53984\", \"type\": \"LOG\", \"step\": [791, 8], \"data\": {\"train_iter_time\": 3.8190674779907567}}\r\n", + "DLLL {\"timestamp\": \"1613260244.023696\", \"datetime\": \"2021-02-13 23:50:44.023696\", \"elapsedtime\": \"24196.55019\", \"type\": \"LOG\", \"step\": [791, 9], \"data\": {\"glob_iter/iters_per_epoch\": \"5729/13\"}}\r\n", + "DLLL {\"timestamp\": \"1613260245.681414\", \"datetime\": \"2021-02-13 23:50:45.681414\", \"elapsedtime\": \"24198.207908\", \"type\": \"LOG\", \"step\": [791, 9], \"data\": {\"train_loss\": 0.3484034538269043}}\r\n", + "DLLL {\"timestamp\": \"1613260247.85958\", \"datetime\": \"2021-02-13 23:50:47.859580\", \"elapsedtime\": \"24200.386074\", \"type\": \"LOG\", \"step\": [791, 9], \"data\": {\"train_items_per_sec\": 4593.712355099718}}\r\n", + "DLLL {\"timestamp\": \"1613260247.859712\", \"datetime\": \"2021-02-13 23:50:47.859712\", \"elapsedtime\": \"24200.386206\", \"type\": \"LOG\", \"step\": [791, 9], \"data\": {\"train_iter_time\": 3.8358953800052404}}\r\n", + "DLLL {\"timestamp\": \"1613260247.872248\", \"datetime\": \"2021-02-13 23:50:47.872248\", \"elapsedtime\": \"24200.398742\", \"type\": \"LOG\", \"step\": [791, 10], \"data\": {\"glob_iter/iters_per_epoch\": \"5730/13\"}}\r\n", + "DLLL {\"timestamp\": \"1613260249.598021\", \"datetime\": \"2021-02-13 23:50:49.598021\", \"elapsedtime\": \"24202.124515\", \"type\": \"LOG\", \"step\": [791, 10], \"data\": {\"train_loss\": 0.30499666929244995}}\r\n", + "DLLL {\"timestamp\": \"1613260251.850263\", \"datetime\": \"2021-02-13 23:50:51.850263\", \"elapsedtime\": \"24204.376757\", \"type\": \"LOG\", \"step\": [791, 10], \"data\": {\"train_items_per_sec\": 3994.6926921589716}}\r\n" + ] + } + ], + "source": [ + "!tail -n100 output_michaelrosen2/nvlog.json" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [], + "source": [ + "import json\n", + "training_loss = []\n", + "val_loss = []\n", + "with open(\"output_michaelrosen2/nvlog.json\", \"r\") as f:\n", + " for line in f.readlines():\n", + " data = json.loads(line[5:])\n", + " if \"data\" in data and \"train_loss\" in data[\"data\"]:\n", + " training_loss.append(data)\n", + " if \"data\"in data and \"val_loss\" in data[\"data\"]:\n", + " val_loss.append(data)" + ] + }, { "cell_type": "code", "execution_count": null, @@ -440,123 +524,136 @@ }, { "cell_type": "code", - "execution_count": 67, + "execution_count": 34, "metadata": {}, "outputs": [ { - "ename": "ModuleAttributeError", - "evalue": "'ModuleList' object has no attribute 'requires_grad'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mModuleAttributeError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mencoder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconvolutions\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrequires_grad\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m~/anaconda3/envs/pytorch_p36/lib/python3.6/site-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m__getattr__\u001b[0;34m(self, name)\u001b[0m\n\u001b[1;32m 777\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mmodules\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 778\u001b[0m raise ModuleAttributeError(\"'{}' object has no attribute '{}'\".format(\n\u001b[0;32m--> 779\u001b[0;31m type(self).__name__, name))\n\u001b[0m\u001b[1;32m 780\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 781\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m__setattr__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mUnion\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mTensor\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Module'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mModuleAttributeError\u001b[0m: 'ModuleList' object has no attribute 'requires_grad'" - ] + "data": { + "text/plain": [ + "6171" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "model.encoder.convolutions.requires_grad" + "len(training_loss)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [], + "source": [ + "steps = [t[\"step\"][0] for t in training_loss]\n", + "loss = [t[\"data\"][\"train_loss\"] for t in training_loss]" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt" ] }, { "cell_type": "code", - "execution_count": 71, + "execution_count": 45, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n", - "True\n" - ] + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAD8CAYAAABn919SAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO3dd3hUVfoH8O+bBqEFhFADhA6hQ+gLgiBFFBQsgLroqriu/nDRVYNdUETZtWPBgmVVZFUUDYKCWOgEqQECAQKEIiF0AqSd3x9zZzLlzsydyUwmc/P9PE8eZu49M3O4mbz33PeUK0opEBFR+IsIdQWIiCgwGNCJiEyCAZ2IyCQY0ImITIIBnYjIJBjQiYhMwlBAF5HhIpIhIpkikuKmzI0isl1E0kXks8BWk4iIvBFv49BFJBLALgBXAsgGsB7AeKXUdrsyrQDMB3CFUuqkiNRVSh0LXrWJiMiZkRZ6TwCZSqm9Sql8APMAjHYqcxeA2UqpkwDAYE5EVPaiDJRpBOCg3fNsAL2cyrQGABFZCSASwNNKqcXObyQikwBMAoCqVat2b9u2rT91xtZDp3W3d2wUZ9vXsVGcX+9NRFSebdiw4bhSKl5vn5GALjrbnPM0UQBaARgIIAHA7yLSQSl1yuFFSs0BMAcAkpOTVVpamoGPd5WYkqq7/ddnhqH9U0sAAGkzR/r13kRE5ZmI7He3z0jKJRtAY7vnCQAO65T5VilVoJTaByADlgBfpi4UFJX1RxIRlRtGAvp6AK1EpJmIxAAYB2ChU5lvAAwCABGpA0sKZm8gK2rEhXwGdCKquLwGdKVUIYD7ACwBsAPAfKVUuohME5FRWrElAHJFZDuA5QAeUkrlBqvS7vR/cTkAIEIvSUREZHJGcuhQSi0CsMhp25N2jxWAB7SfkIuNjgx1FYiIylxYzhStWSXa4/7KDOhEVAGFZUC/8y/NPO5nQCeiiigsA3qElyR5bAwDOhFVPGEZ0KO8BXS20ImoAgrLgB4hDOhERM7CMqB7a6FXZsqFiCqgsAzokZGeq105Kiz/W0REpRKWkS/SS8olhgGdiCqgsIx83lIu4iXgExGZUVgG9EjO7ScicmHagD57eSY+WLGvDGpDRFQ+GFrLpbzxFtC/23wY3222PP6bl1mlRERmYdoWOhFRRcOATkRkEmEZ0OvVqBzqKhARlTthGdBrVPY99f/5ugOY/PnGINSGiKh8CMuA7o+pX2/Fws3Ot0IlIjIP0wf0xJRUnM4rCHU1iIiCzvQBHQD2HD8X6ioQEQVdhQjoY95c5fD8YkERElNSkXnsbIhqREQUeBUioNu7VFiEt3/dAwAY8tJvIa4NEVHgVLiAnjx9KV5Zutv2PC+/0KXMr7ty8K//bbY9zzh6FoVFxWVSPyIif1W4gH72kmMALypWLmUmfrAOX27IBgAcPX0Rw175DQ/aBXgiovIoLAN6/bjATSz6dVeOx/255y8BAHb9yY5VIirfwjKgV4mJQnLTWgF5r/s+24jMY+eQmJKKV+1SMURE4SYsA3qg/ePTDQCAN5YzoBNR+ArbgB4RwLsSMZ1CRGZgKKCLyHARyRCRTBFJ0dl/m4jkiMgm7efOwFfV0bPXdQj2RxARhRWvq1yJSCSA2QCuBJANYL2ILFRKbXcq+oVS6r4g1FFX63rVy+qjiIjCgpEWek8AmUqpvUqpfADzAIwObrXKt/d+34vth8+EuhpERA6MBPRGAA7aPc/WtjkbKyJbRORLEWkckNqVsYIihWe+S9fdt+PIGSSmpCLj6Fk8m7oDV732u6H3TExJRevHfghkNYmIdBkJ6Hq9j86zcb4DkKiU6gRgKYCPdN9IZJKIpIlIWk6O5/HfoTJ3ZZbH/cNeKVkuoKCoGN9sPIRinclJ9vI5y5SIyoCRgJ4NwL7FnQDAYWFxpVSuUuqS9vRdAN313kgpNUcplayUSo6Pj/envmXKsoCX+xEwd32chn9+sQkvLsmAUp6DOhFRsBkJ6OsBtBKRZiISA2AcgIX2BUSkgd3TUQB2BK6KofXtJvc3xdifmwcAePvXPRj6Mhf6IqLQ8hrQlVKFAO4DsASWQD1fKZUuItNEZJRWbLKIpIvIZgCTAdwWrAqXtTb13Y+m2Xf8vO3x7mPncPBEHvbkcEw7EYWGoZtzKqUWAVjktO1Ju8dTAUwNbNXKh0gfJjD1f3E5ACBr5shgVYeIyK2wnSla0Ww6eAqJKan4SlsFkojIWVgH9CeuTgp1FcqMddx72v4TIa4JEZVXYR3Q7/hLs1BXQde5S643zSAiCrawDujlVYenlmDnUc4kJaKyxYDuxRvLM/163d6c894LEREFEAM6EZFJMKCHwM6jlnVhLhUWhboqRGQiDOgh8J8fdwEAfskon+vZEFF4YkAPojm/7Ql1FYioAjE0U5R8949P/wh1FYiogmELvYwkpqRyRUYiCioG9DJU5GXddCKi0mBAL0Mn8wpCmlef9t129J6xLGSfX9Es3nYEjy3YGupqUAXCgF6Gejy3FDMW7cTeEC2x+8HKfTh65qLL9gUbs5GYkorTeQUhqJV5/f2/f+DTtQdCXQ2qQEwV0OtUiwl1FQzZ42UW6TPfpWPq12XXspu3znLL2O1HuFwBUTgzTUDPmjkSaY9fGepq+OTuTzbobp+7Mgufr/Pcsjt+7hJyzl7yWKa8WZV5HBvCZLXI2cszsTLzeKirQeQT0wR0MzrvYdXG5GeXosdzSz2+PjElFYkpqYGult8mvLcWY99aHepqGDJrSQZufm9tqKtBZWTD/pO4WOD/zO28/EJsPHAygDXyDwN6Odb+qSXILyzGvZ/+gWIDQx735pxDYkoqVu05js0HT5VBDSumgqJiTP16i8Mw1Ds/SsPxc+F1xUQWuecuYexbq9xeMRtx0ztrcN2bq0p1UggEBvRy7pb31iJ16xF8sd6S5/5cy3frsaYIFm09gns/48SmYHn950x8vu4g/qfdPSot6wSW7vgTj3y5JcQ1c3Xs7MWQ1utiQRFOnM8PyWdnn8zDYwu2IjEl1WOf1NmLlivhrFz/V0i1vvZSYbHf7xEIDOgh1nXaj7hYUIQN+0+gWGec+rosS875fL779Mv077djS7Zji1zvvfSszzqBDftDf6nor1935eBkGQeMsxcLtH8tv5OLBZY/4ovlcLG1yZ9vxBdpB5Fx9Kzu/oGzluPGt4OXBus2/Sd0m/5TwN7vQn4RDuTmGSo78YN1tlFGv+2qGOsmmS6gPz+mY6ir4JOTeQX457xNGPvWasxenonvNh/26fVr9+bi/RX7MOqNlbZtp/IKcPi06/BEPTe8vRqFYTrh6dylQkz8YB3u+Gi9w/YDuXnlch2dtXtzy3xy2YV8y0nmgpYKSExJxX9+zLDtz8rNszUagiEvP7Anub99uB4DZi03VPb8Jf3PLi5WaP3YD5j0cRpm+3m/g/LKFAG9R2It2+PxPZsgLjYaAFC9cngsVWNt2f26Kwcv/bRLt4y7G2bcNGeNy7b0w8aGH/71g3WGyjl3riqlDAemxduOGv4cX1nzlfudWmyjZ6/AjEU7fQ6ewcx/7jx6BjfNWYNp36UH7TOMev3n8A1iq/fmlvo9bv1gLfKLivHj9j8xa0mG9xeUQuaxs0hMScWuP/WvkAIt7AP63hlXYf7dfXT3/f7wIGTNHIkVjwwq41r5pnplywkobf9JQ+u9WC/5S0Mp5fdlaPNHF6HFo4sMlf37fzcE7XI3X8tXRkc6fo3PaKkQpRRyz13CsbPer1ZmL89E2ycWl2rS18rMXN0TcmJKKn5K/xMAsM9guiDYElNS8ZcXfg51NUJiZWbpTwpGLdx8BACQuuVImXxe2Af0iAiBiHgsk1CrShnVpvSyDPzBd3z6R93t1svqfccdW/OJKakuIzB+3P6ny+vHv7vG1hpfsDHb7cnFnzXGCopKOosSU1KRX1iMA7l5SLO73P9+y2E0m2psmOWT327DES2tFB3l/vff/dml6Pmc43IHbR7/AVO/duwotPYjOB87T9IPn8Yxp5m3ry3brVv2642HHJ6vyjyObzcd0i0LAN9sPGSZvXsheLN3s09eCNp7B1tiSip+2v4nso6fd/hulTeFRdZGh+cYFShhH9DNYHeALsdmLNrpdt/OI46f4W2I1pQvNuP9FfsCUi8AaPXYDw7Pr3l9BQbMWo7r7TrkHv5yC5TyPP4esByvj1fvx10fpwEAYiK9f42//iPb9vhSYbHH0UJ68guLkZiS6hCwv/7jEAb++xef3sdqwntrcf+8TbonWwD4TOvM2+nD7N1Dpy6gz/PLcPBE+bgK8JXRzk6rN37ejYH//gV3fpQWpBo5mr080+3vyx1r/1SUge9oIDCglwM73YxACLXskxe8tpg/WbMfv+/2PaWSUYqTmPVKxDoczjnloueB+ZvxwPxNDtusE0EOn7qAQ15aqyfzLJ/13zX7HbYHotPvkS+32K6M7p+30WGfXh+JO1+mZePI6Yvo/2JJp2FBUdl1wloDnrcTsp41e3MxYNZyfLw6y/Brzmqf424ET6At22G5qt3vw/BG69VDVARb6BRAt7zv+6zH33bleE2vPPHNNtz6fmA7PXs/b0mRHDtzEb1mLMUdH67Hj+lH3ZaPiTL2Nf76D8cUh7UV3Hfmz25PMEop9Jv5M7J8SMUAcDtD97ddOS4t6GU7j9kef7vJMsrJnyGQeqkH6/o8vg7tPHbmIlbvycWfOou5ubNASysdPuV6cvx07X6Xbfasnf47/FxP6Nnvt2PbodN+vTaYCrUTqtHvaGkxoJNbzrF88bYjtmFwzk7nFWgTOEpy0/7e0MM6vvu5RTvw55lLWLbzGCZ9sgEnz+cjMSXVYYgmAGzJPq0bQFs6pXkAS0vQF+uzTuLQqQt4NIDL4E4yMCPROXe+/bDlxuKeppc7B3T7CT1nLhbg6YXGR9j0nLEM499dg14zlgVkCOhjC7YZLrtgY7bPN1B/b8U+XP36CgCW9Frf5x37Tc5eLAj4UhjtnliMV5fq95lYlbTQy1FAF5HhIpIhIpkikuKh3PUiokQkOXBVpPLihcUZaPfkYtvzXLtcYudplo7atftKOjnnpxnLU5+9WIA9TqNLnvhmm621avWbH6kdZ+PsUhgXCoq8/oHf+I4lxx/I4eNGgpVzQP95p+Vy/+PV+5GYkoqlOp3a9umVk+fzHeY0PJe6Ax+uyvKrvtsO6bea/7tmP4a/8ptf7+lOxtGzmPLFZjxsN7v1sQVbdSe/uVvu+YH5m13mYVhHPnlTXKx0v7cPzt+MPw5YJu/lnM1Ht+k/4UJBEV5eqj/M2Mr6Owlkg8ATrwFdRCIBzAYwAkASgPEikqRTrjqAyQC4olE5d/1bqwyV8zbio/uznhcHO37O2GV+x6d/xOD//Oqw7ZM1ni/RA+F7naFkd3yU5nMntXM6a+7K0nUmJ6ak4pRTsLIO0bSmFRbojJCxb6Hf8M5qPGXXIj9rMKB50vf5ZWhpN1z18W+2YefRs9iw/wSUUsg8Zjkp557Pt43u8GTwf35BYkoqiosVioot5a1B88CJPCSmpOKpb7fh07UHMFbnO5sboBnC+XZ1fWXZbjz85RYsST+Kl37aZbsi/cquU33Wkp0OVz+HT11we3wLix2Pw/bDZ2zHKRiMtNB7AshUSu1VSuUDmAdgtE656QBeBGA86RYkg9rEAwCqxJRMLNr85FCM79k4VFUqV9KCPNV/6tdbsGH/yYBP2vglw3sL/eCJvFLPxrzyZc+tzrkrszzuf+a77S7bHE6OPlYvMSUVm7Itgdy6SFslu5zsF+sPIDElFZvtln/wJfdt1OHTF1FYrJCYkurQDzD2rdVoNrUk0I+bswa3zV3v8nr7q6HiYmW7L0CXaT/iiW8d00HWK5TUrSV9J19tyIae/FIOWxyq/b735+bZRjHd/ckGvLZsN6anbsfWbMfcvPPXy37ZjacXpjsce/urzFWZx3HVa79jyEuOjZdAMhLQGwGwvwbJ1rbZiEhXAI2VUt97eiMRmSQiaSKSlpMTvLUVXhnXFVkzRzp0RMRVidYdj16zimVST/P4qkGrj1kYGaOtlGUBMb0WlTfeRows2Oh+3LaVNUVSnu31sYMVKFmLxNotUSkq0rZv3T7LCXqLXeDxp0We8tUW7DxqrFNyq5cOyBWZx9FvpuvEpZe1iVczF5cMsTWaDnnwf5t1t9u3lu2/d3p35/LVZ2sP4Jo3Vhguv2DjIfTSbvPo3Ic0oQyWYzYS0PXG29hqKiIRAF4G8KC3N1JKzVFKJSulkuPj443XMojqVKvk8PyZUe1DVBMqrTs+XG+bbGRWei10+3SAvxJTUjFv/UGMm7PGZeikHiPj4w/pjHZ5VWsBB+s2jGWx0Jxzw0bvgnD1nlzbsMqyZCSgZwOwz1UkALDvraoOoAOAX0QkC0BvAAvDoWO0f6s6iI2OdNhWIzY81n8pr3yZaRlo9sP/Ai2U/y971thRKdryp2t0Vc0LBtepOZVX4NIZDVhGnth7rRTrwSSmpGLpDs+/q+wT4TOL9d3f97psG//uGpw6736Wb36Qltk1EtDXA2glIs1EJAbAOAALrTuVUqeVUnWUUolKqUQAawCMUkqVzfStUvj3DZ29lrl/cCu0b1ijDGpD5J21f8Cacun49JIy+dwpX+inO4KltHnxsuTcgW3bfsF9p+2ULza53VcaXpujSqlCEbkPwBIAkQA+UEqli8g0AGlKqYWe36H8qF+jMgBg+rUdcGvvpgCA+OqWlEsNbYEsZ1OubI242GikH96Ozglx2Jxd/iYvUNk5FuL7uFrXX3lt2W7EV6+E8wFenlZPWa0UqCec7wJ10k2gB/zrRzHCUH5BKbUIwCKnbU+6KTuw9NUKjrHdEyACXNe1pE/39fFd8f2Ww1i9Jxeb3Ny27W9/aWb5+dC1554oVJ74xvhkndLQy4WTd6fyyv5OTRVupuiYbgkOqzNWrRSFm3o0cShjbbU7q+tmO5GZBWIMe0XkLhUTTBUuoLtjDfICwaqUK3TLPHF1Eh4f2a4sq0VEYeopH5ZaCBQGdM2DQ1sDAEZ0rO929b6qlaJwZ//mZVktIirnyssIKIAB3SahVhVkzRxpGz0wplsjPHddB4+vYWudiMoTDrp246Ubu7jdlzVzJADXsblERKHEFjoRkUkwoBMRmQQDegB1bVIz1FUgojAQrMlaDOgB9PHfeoa6CkQUBkq7xLM7DOil0Lpedbf7nFvrXJ6XiIKNAb0U2jeMw+7nRrhsr1YpCn2a19Z9TUKtWHRubAn2NyYnBLV+RFSxMKCXkrtJSM5qV40BACQ1qGFbQmBwu3pBqxcRVTwchx4AX0zq7XC7Oz1v3twdyzOO4ZpODTHZwA0EiIh8xYAeAL209MrZi+4X44mvXgk3Jvt+T9NmdaqWq6nFRFR+MeVCRGQSDOgBVK2S5YLn6TK6L2n3prXK5HOIKDwwoAeQiCBr5khc3z1wo1da1q3msi1r5khkzRyJqtoJpFkd90MioyP17vFNRGbEgB5kE/s0tS3m5Y9xPRrjh/v76+6zDo1s7iag92tZG3+/vIXfn01E4YUBPcjqavcx9ea2vokAgFGdGzps7928Nto1qIF1jw12ec09A1sga+ZINL6sitv3vWjwbu9EFP4Y0MuJp0e1R9bMkXhtfFekPT4EgGXsujWtUrd6ZVvQ98XFgvC4e/qLYzuFugqm5s93h8IPA3oYsQZ9X4RLC71yTGSoq2BaretVQ+/ml4W6GlQGGNBDoL6WhqlTLfg3nb5YaLyFfsdfmjk8t3a2xkQF52vy1T19bI/bN6xh6DWt67l2EhtVvVLpp13wRuFUnjGgh8CT1yRh1vWdymTYoV4LvZpOYOvfqg6euDrJYZt1+OW8Sb1dys+9rQdqVYm2Pb8yqR662S1IFmE3uKZV3Wq6n9m9aUmrsUW8fhlnP0653O0+b1cv8TWMB2N3Hc3ePHVNkvdCpfTbQ4N8fk2QFvcLmX8M9L+zv5uJl7lmQA+B6MgI3KDNGp1xXcegBnal84e87ZlhePZax/ulvvvXZADAkHZ1AQAiwOWt45E1cyS6NanlEiwHta2Lhff9xe3nNqwZa1t87MokY2vWvHVLN5dtzp3EgeBpmKfVnL929/l9+7Wsjdv7NcPr47v6Uy3DmtR23wmuJ0IE2SfzdPeN7NgA43t6nsFsPV4dG8Xh87tcT+5lwfn79/Dwtph+rf49f1Mnu/9ejunaCFd1bAAA+Fu/Zm7LhSsG9BCb0KsJvrqnb6neo0eiY350QOt422N3N7pOqBXr8LxytCWH/d7EHlgzdTDSnxnm8hrnkTb2o2uiIhzHuxcUFaNpbe+B88bkBHx4ew8AQP9W8S77XxvfFZOvaOn1fdzp0rim7YRiTSlN6NnEtn/vjKtcXjOxT1O0rFvda4vf3YnhGh9OQq+Oc3/vWl9EeJhu8PJNXRAh7gvonfTtVdJSbrHRkejTQn8VUWdjujZCG6flpesbHPHlTdv6lvetUVn/iq59wzi3r314eFvbYw+HRNfSBwbg+/9zf7KwN6ZbI9/ePEAY0IPkph6WVs91XX3/xVpTD86B2p2RnRrYHq94ZBCmjrB8aRvExaKeH39E9eMq6y42Vre6+/d60inVkO8hd//C2I54RPvDevH6zhjYpq6hek0Z0tprmRfGdnS7r061SsiaORJxsZZU0Q3dExChEwmfGV1yEpw9wfWqwV8dG7kGmtFdGuHxke18fi/nCWN7nx+JGdfp/9/bNaiBiX0TMfe2Hrr7p47w/Pmt61XH1Z0a4DUfrjxeuqkLlkwZ4NBwiI7yb5JbX+0kMrx9fTx1TRIW/3MAAKBGbLTb10we3Ep3e+XoCNsVcb+WjienkR0b6L3E5rKqlZDUwLWvp3OC6+/V/ibzn97Zy/b4rZsD933Sw4AeJE1rV0XWzJFoWDPWe2EnlaMjsWfGVbopCG8SalVBuwY18MaErm7/wEujbvVKeGOC6x92gzjH/2dBkbK17Kytf6ubejTBPaXIgVqtTLnClg/94LZk23tHemqu6nhPSzfpuUxb9ripj2kOPf+9o5f3QgZlTHddh9/TTVSiIyMwqK3+iTOuSjSmj/a8XMUbE7qhfpzlhO7peDlb8cgVtsfj7a6MfHFX/+YAgLdv7Y7b7dIkNSq7D+gPXNla94qgcnQkumopxCvaOqYCc89f8qt+bet77tDv17KO7XFskEdzGQroIjJcRDJEJFNEUnT2/11EtorIJhFZISLB7xkyucgIgfh6TWjn6k4NXUanvHRjZ4fWvFX/VnVctrmz7rEhuLqT95RCfmExbuubiD7NHWerbn16qMfXvX1LN8O38mtUMxZzb+uJfi1rY5DBVj4AdGtqOQkM1voLhiTVw8wxnk9+Mdq696X5g4yroh+ArOvif3tvP9u6+c5mjunoMAopIsKyzMTUEW1xe79EAJZJaFarp17h/BYejfMh2A5x0ycS72YEkHWpCusVZyMvjZxezRyvTHu7uVlMXKzvo5YqOf1N2I80Kyjyr+e48WWxDum3QIym8pfXgC4ikQBmAxgBIAnAeJ2A/ZlSqqNSqguAFwG8FPCakkc/3N8fL93YWXfft/f2w9zbe2BMtwSXFMKA1vH4pBQtx2ev7YBP7rAE4L4tSk4MDw5tjajICHw+qTdioiIwTWsBehvJMrxDAwxoHY/2DWvYWseexFWJxqd39vbp5GfNjw/vUHJy8xbQLqsag/E9m+Cj20t331i99EqzOparuc6Na+JOrTWq54mrk1zy+ndf3gJPXVPSuv7toUF4dVwXlysmb6IjI/waPWO169kRtlSWO9Yrp8aXxTp0rt7cy3LsrVeUa/edsO2rU62S25NoQq0qPgdPd9+TW3o3wSs3ee7PcD4ZWOUXKdi/6yrtZDr39h54aFgbh7LWFFSdat6/2/4wcjR6AshUSu0FABGZB2A0gO3WAkqpM3blqwIw2SCp8q9dgxpop5PfA2C75Z096x9fLTetRqNu6d3U9vhfw9rgX05fYKsx3RIwppvxRctSJ+uvXxNM43s2xob9Jx22ddGO3T8GtcTlrV07bY365V8DAQB39m+OZTuOYfXeXLw/0TV1cc/AFnhh8U4AwJqpg9H7+WU+fU6T2lVso2Den5jsku7y9tqHhrXBrCUZPn0mYGyuQtfGNdGmXnW8OLazw0id567riOeu64jiYoVHF2xFfPVKyDnrPf1ROToSW58ZhsSUVJ/raxUXG4Xj5y7hoaFt3V5BAZY0U9VKUSjWGf/Zul41XLLrM6qupYIGtanrcuXYIr4adj83wmMndWkYSbk0AnDQ7nm2ts2BiNwrIntgaaFP1nsjEZkkImkikpaTk+NPfSlAujaphSlDWmPmGE65t3p+TCeXce6xMZHImjnSr2B+V/+SFEmizoiYWDfBtnJ0BGpWibblrP01uF09h/wtAKxKsbQerR3nzu4dVDKi6I8nrgQATOzbVLesO+6GqYoIlkwZYAvmO6cPxxa7FFxEhGD5vwbiOw/DYX3RysAktM/u6o2pI0qC+dU6KUmgJM0UESF459aSIa1LHxiAqzs1REGRsQl8IoLoyAif+3mMMtJC1/tkl9OUUmo2gNkiMgHA4wAm6pSZA2AOACQnJ7MVH2L3D9EfCVDeDGxbF6/9nImBbYwF1QgBQr3ggTU18u7v+3x+7U6dDs9AaVgzFlkzR+JUXj6e/2GnLf+u57KqMX6tFPqwm6s0Z5WjI12uIIzMEfDE/qrn/Yk9cPBkHlrEV3Pbiq9XozLutuvjqerlVpIAMKx9fdvjlnUtQyjztYAerFSKUUZa6NkA7GceJAA47KH8PADXlqZSRPasE5vsU0eelk14f6L+8LxwFujRETWrWIJ1ssGhsc6mX9sBP00Z4LDtHi0w+jrxSY8vE5hWPFKS+7e/8XpMVARaxPu3VMSkAc2x+SnL1YOR7MiLYzuhbf3qWPvoEL8+L1CMtNDXA2glIs0AHAIwDsAE+wIi0koptVt7OhLAbhAFibdW44DW8fj6H30x5s1VQfn82/slYu7KLJ8nppRGMGbMlsatvV3TMGO7J2BsgG7u0qKu8ZZ6Qi3vJ5BVKVcgL7/Q8Hs2r1MVcSR6DC4AAAowSURBVLHRhq9Qhravj6F2LfdQ8dpCV0oVArgPwBIAOwDMV0qli8g0ERmlFbtPRNJFZBOAB6CTbiEym+u7JyAmMsLjbM9v7+2HdY+6rmVv1NCkeph/d59SDWElS6rJmh7xpH0jy8ACvTuFhQNDY36UUosALHLa9qTd4/sDXC+iUrEuRRDMW/BViorErudG4ECuZZ2Ubk1c1+TRG2Hkizk+TOKh0vtrn0QMTarvtUP614cG4vCpiz69t96M0kAL3Qh4oiDq2CgOSQ1qYNb1nfHST7sAAFUClIe2Dg+1LuXbpHYVbJ82zO2oFWdjuydg9d5ct8NMQ+3Nm7vpLlNQURgZXdS0dlVDaxVZleY2lL5gQCdTEhEs0u7FOv3aDigsLtZd/MsfNyY3Rt8WtR1yt3pr37hzffeEgN5IPNCu8rKmSXnF++cyoFMFEBcbjTdv9n05XE+MdMRR2SmrFnB5x4BORH6b0KsJeiQGfj3/eG1Y6tOjuCyUL0R5Www5SJKTk1VaWlpIPpuIKFyJyAallG5vOZfPJSIyCQZ0IiKTYEAnIjIJBnQiIpNgQCciMgkGdCIik2BAJyIyCQZ0IiKTYEAnIjIJBnQiIpNgQCciMgkGdCIik2BAJyIyCQZ0IiKTYEAnIjIJBnQiIpNgQCciMgkGdCIik2BAJyIyCQZ0IiKTYEAnIjIJBnQiIpMwFNBFZLiIZIhIpoik6Ox/QES2i8gWEVkmIk0DX1UiIvLEa0AXkUgAswGMAJAEYLyIJDkV2wggWSnVCcCXAF4MdEWJiMgzIy30ngAylVJ7lVL5AOYBGG1fQCm1XCmVpz1dAyAhsNUkIiJvjAT0RgAO2j3P1ra5cweAH/R2iMgkEUkTkbScnBzjtSQiIq+MBHTR2aZ0C4rcAiAZwCy9/UqpOUqpZKVUcnx8vPFaEhGRV1EGymQDaGz3PAHAYedCIjIEwGMALldKXQpM9YiIyCgjLfT1AFqJSDMRiQEwDsBC+wIi0hXAOwBGKaWOBb6aRETkjdeArpQqBHAfgCUAdgCYr5RKF5FpIjJKKzYLQDUA/xORTSKy0M3bERFRkBhJuUAptQjAIqdtT9o9HhLgehERkY84U5SIyCQY0ImITIIBnYjIJBjQiYhMggGdiMgkGNCJiEyCAZ2IyCQY0ImITIIBnYjIJBjQiYhMggGdiMgkGNCJiEyCAZ2IyCQY0ImITIIBnYjIJBjQiYhMggGdiMgkGNCJiEyCAZ2IyCQY0ImITIIBnYjIJBjQiYhMggGdiMgkGNCJiEyCAZ2IyCQY0ImITIIBnYjIJAwFdBEZLiIZIpIpIik6+weIyB8iUigi1we+mkRE5I3XgC4ikQBmAxgBIAnAeBFJcip2AMBtAD4LdAWJiMiYKANlegLIVErtBQARmQdgNIDt1gJKqSxtX3EQ6khERAYYSbk0AnDQ7nm2to2IiMoRIwFddLYpfz5MRCaJSJqIpOXk5PjzFkRE5IaRgJ4NoLHd8wQAh/35MKXUHKVUslIqOT4+3p+3ICIiN4wE9PUAWolIMxGJATAOwMLgVouIiHzlNaArpQoB3AdgCYAdAOYrpdJFZJqIjAIAEekhItkAbgDwjoikB7PSRETkysgoFyilFgFY5LTtSbvH62FJxRARUYhwpigRkUkwoBMRmQQDOhGRSTCgExGZBAM6EZFJMKATEZkEAzoRkUkwoBMRmQQDOhGRSTCgExGZBAM6EZFJMKATEZkEAzoRkUkwoBMRmQQDOhGRSTCgExGZBAM6EZFJMKATEZkEAzoRkUkwoBMRmQQDOhGRSTCgExGZBAM6EZFJMKATEZkEAzoRkUkwoBMRmQQDOhGRSTCgExGZhKGALiLDRSRDRDJFJEVnfyUR+ULbv1ZEEgNdUSIi8sxrQBeRSACzAYwAkARgvIgkORW7A8BJpVRLAC8DeCHQFSUiIs+MtNB7AshUSu1VSuUDmAdgtFOZ0QA+0h5/CWCwiEjgqklERN5EGSjTCMBBu+fZAHq5K6OUKhSR0wBqAzhuX0hEJgGYpD09JyIZ/lS6HKkDp/8j8Zi4wePiisfElZFj0tTdDiMBXa+lrfwoA6XUHABzDHxmWBCRNKVUcqjrUZ7wmOjjcXHFY+KqtMfESMolG0Bju+cJAA67KyMiUQDiAJzwt1JEROQ7IwF9PYBWItJMRGIAjAOw0KnMQgATtcfXA/hZKeXSQiciouDxmnLRcuL3AVgCIBLAB0qpdBGZBiBNKbUQwPsAPhGRTFha5uOCWelyxDTpowDiMdHH4+KKx8RVqY6JsCFNRGQOnClKRGQSDOhERCbBgO6FiESKyEYR+V573kxb3mC3ttxBjLa9wix/ICJZIrJVRDaJSJq27TIR+Uk7Lj+JSC1tu4jIa9px2SIi3UJb++AQkZoi8qWI7BSRHSLSpyIfExFpo30/rD9nROSfFfmYAICITBGRdBHZJiKfi0jlQMYUBnTv7geww+75CwBeVkq1AnASlmUPgIq3/MEgpVQXuzGzKQCWacdlmfYcsCwZ0Ur7mQTgrTKvadl4FcBipVRbAJ1h+c5U2GOilMrQvh9dAHQHkAdgASrwMRGRRgAmA0hWSnWAZZDJOAQypiil+OPmB5Yx98sAXAHge1gmUB0HEKXt7wNgifZ4CYA+2uMorZyE+v8QpOOSBaCO07YMAA20xw0AZGiP3wEwXq+cWX4A1ACwz/n3XZGPidNxGApgZUU/JiiZUX+ZFiO+BzAskDGFLXTPXgHwMIBi7XltAKeUUoXa82xYfkmA0/IHAKzLH5iRAvCjiGzQlnMAgHpKqSMAoP1bV9uut3REI5hLcwA5AOZq6bn3RKQqKvYxsTcOwOfa4wp7TJRShwD8G8ABAEdgiREbEMCYwoDuhohcDeCYUmqD/WadosrAPrPpp5TqBstl8r0iMsBD2YpwXKIAdAPwllKqK4DzKEkl6KkIxwQAoOWDRwH4n7eiOttMdUy0/oLRAJoBaAigKix/Q878jikM6O71AzBKRLJgWWHyClha7DW15Q0Ax2UQKszyB0qpw9q/x2DJi/YE8KeINAAA7d9jWnEjS0eEu2wA2UqptdrzL2EJ8BX5mFiNAPCHUupP7XlFPiZDAOxTSuUopQoAfA2gLwIYUxjQ3VBKTVVKJSilEmG5ZPxZKXUzgOWwLG8AWJY7+FZ7XCGWPxCRqiJS3foYlvzoNjj+/52Py1+1UQy9AZy2XnKbhVLqKICDItJG2zQYwHZU4GNiZzxK0i1AxT4mBwD0FpEqIiIo+Z4ELqaEuqMgHH4ADATwvfa4OYB1ADJhuYyspG2vrD3P1PY3D3W9g3QsmgPYrP2kA3hM214blg7k3dq/l2nbBZYbpOwBsBWWHv6Q/z+CcFy6AEgDsAXANwBq8ZigCoBcAHF22yr6MXkGwE5YGkGfAKgUyJjCqf9ERCbBlAsRkUkwoBMRmQQDOhGRSTCgExGZBAM6EZFJMKATEZkEAzoRkUn8P8TnjpgTr9ddAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" } ], "source": [ - "i = 0\n", - "for param in model.parameters():\n", - " print(param.requires_grad)" + "axis = plt.gca()\n", + "axis.set_ylim([0, 0.6])\n", + "plt.plot(steps, loss)" ] }, { "cell_type": "code", - "execution_count": 73, + "execution_count": 50, "metadata": {}, "outputs": [], "source": [ - "for param in model.encoder.parameters():\n", - " param.requires_grad = False" + "steps = [t[\"step\"][0] for t in val_loss]\n", + "losses = [t[\"data\"][\"val_loss\"] for t in val_loss]" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 53, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 53, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ - "for param in model.parameters():\n", - " " + "axis = plt.gca()\n", + "axis.set_ylim([0.3, 0.4])\n", + "plt.plot(steps, losses)" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { From 96f5cb76e68392e5a504640ecf6e93bca6187a3c Mon Sep 17 00:00:00 2001 From: Ubuntu Date: Sun, 14 Feb 2021 18:37:23 +0000 Subject: [PATCH 04/16] add train_multiproc.py --- .../Tacotron2/train_multiproc.py | 87 +++++++++++++++++++ 1 file changed, 87 insertions(+) create mode 100644 PyTorch/SpeechSynthesis/Tacotron2/train_multiproc.py diff --git a/PyTorch/SpeechSynthesis/Tacotron2/train_multiproc.py b/PyTorch/SpeechSynthesis/Tacotron2/train_multiproc.py new file mode 100644 index 000000000..55f87dc2f --- /dev/null +++ b/PyTorch/SpeechSynthesis/Tacotron2/train_multiproc.py @@ -0,0 +1,87 @@ +# ***************************************************************************** +# Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# * Neither the name of the NVIDIA CORPORATION nor the +# names of its contributors may be used to endorse or promote products +# derived from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +# DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY +# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# +# ***************************************************************************** + +import sys +import subprocess + +import torch + + +def main(): + argslist = list(sys.argv)[1:] + print(argslist) + return + world_size = torch.cuda.device_count() + + if '--world-size' in argslist: + argslist[argslist.index('--world-size') + 1] = str(world_size) + else: + argslist.append('--world-size') + argslist.append(str(world_size)) + + workers = [] + + for i in range(world_size): + if '--rank' in argslist: + argslist[argslist.index('--rank') + 1] = str(i) + else: + argslist.append('--rank') + argslist.append(str(i)) + stdout = None if i == 0 else subprocess.DEVNULL + worker = subprocess.Popen( + [str(sys.executable)] + argslist, stdout=stdout) + workers.append(worker) + + returncode = 0 + try: + pending = len(workers) + while pending > 0: + for worker in workers: + try: + worker_returncode = worker.wait(1) + except subprocess.TimeoutExpired: + continue + pending -= 1 + if worker_returncode != 0: + if returncode != 1: + for worker in workers: + worker.terminate() + returncode = 1 + + except KeyboardInterrupt: + print('Pressed CTRL-C, TERMINATING') + for worker in workers: + worker.terminate() + for worker in workers: + worker.wait() + raise + + sys.exit(returncode) + + +if __name__ == "__main__": + main() From 4bb22c0b6e6cb103b9b3b72b6da1c6c062181ea8 Mon Sep 17 00:00:00 2001 From: Ubuntu Date: Sun, 14 Feb 2021 19:58:07 +0000 Subject: [PATCH 05/16] fix --- PyTorch/SpeechSynthesis/Tacotron2/train_multiproc.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/PyTorch/SpeechSynthesis/Tacotron2/train_multiproc.py b/PyTorch/SpeechSynthesis/Tacotron2/train_multiproc.py index 55f87dc2f..1d461efee 100644 --- a/PyTorch/SpeechSynthesis/Tacotron2/train_multiproc.py +++ b/PyTorch/SpeechSynthesis/Tacotron2/train_multiproc.py @@ -32,9 +32,10 @@ def main(): - argslist = list(sys.argv)[1:] - print(argslist) - return + # NOTE(zach): this dumb hack will let us invoke train_multiproc.py while + # satisfying the Sagemaker SDK, since Sagemaker doesn't give us full + # control over the command which invokes the training script. + argslist = ["train.py"] + (list(sys.argv)[1:]) world_size = torch.cuda.device_count() if '--world-size' in argslist: From 57e2828b87011d65a2501eac4b49d3477bd35480 Mon Sep 17 00:00:00 2001 From: zach wener Date: Sun, 14 Feb 2021 21:55:00 +0000 Subject: [PATCH 06/16] Revert "Accomodate batch size of 1" This reverts commit 40b1cb360b598bd7d232c658848196cb1fb43277. --- PyTorch/SpeechSynthesis/Tacotron2/tacotron2/model.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PyTorch/SpeechSynthesis/Tacotron2/tacotron2/model.py b/PyTorch/SpeechSynthesis/Tacotron2/tacotron2/model.py index ff0869567..4976b54c3 100644 --- a/PyTorch/SpeechSynthesis/Tacotron2/tacotron2/model.py +++ b/PyTorch/SpeechSynthesis/Tacotron2/tacotron2/model.py @@ -501,7 +501,7 @@ def forward(self, memory, decoder_inputs, memory_lengths): mask) mel_outputs += [mel_output.squeeze(1)] - gate_outputs += [gate_output.squeeze(1)] + gate_outputs += [gate_output.squeeze()] alignments += [attention_weights] mel_outputs, gate_outputs, alignments = self.parse_decoder_outputs( From cd498dfa3257fac6c5eec31513521c7b91814584 Mon Sep 17 00:00:00 2001 From: Zach Wener-Fligner Date: Tue, 16 Feb 2021 12:22:09 -0800 Subject: [PATCH 07/16] fixme --- PyTorch/SpeechSynthesis/Tacotron2/train.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/PyTorch/SpeechSynthesis/Tacotron2/train.py b/PyTorch/SpeechSynthesis/Tacotron2/train.py index 7119a5d04..30ab688f3 100644 --- a/PyTorch/SpeechSynthesis/Tacotron2/train.py +++ b/PyTorch/SpeechSynthesis/Tacotron2/train.py @@ -255,7 +255,8 @@ def load_checkpoint(model, optimizer, epoch, config, amp_run, filepath, local_ra elif 'random_rng_state' in checkpoint: torch.random.set_rng_state(checkpoint['random_rng_state']) else: - raise Exception("Model checkpoint must have either 'random_rng_state' or 'random_rng_states_all' key.") + print("Loading model checkpoint even though rng states were not loaded!") + # raise Exception("Model checkpoint must have either 'random_rng_state' or 'random_rng_states_all' key.") config = checkpoint['config'] model.load_state_dict(checkpoint['state_dict']) optimizer.load_state_dict(checkpoint['optimizer']) From 19cdc9785fb1ec322819bd5254ed47e630b20fcf Mon Sep 17 00:00:00 2001 From: Zach Wener-Fligner Date: Tue, 16 Feb 2021 18:37:02 -0800 Subject: [PATCH 08/16] fix again --- PyTorch/SpeechSynthesis/Tacotron2/train.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/PyTorch/SpeechSynthesis/Tacotron2/train.py b/PyTorch/SpeechSynthesis/Tacotron2/train.py index 30ab688f3..104562785 100644 --- a/PyTorch/SpeechSynthesis/Tacotron2/train.py +++ b/PyTorch/SpeechSynthesis/Tacotron2/train.py @@ -249,7 +249,8 @@ def load_checkpoint(model, optimizer, epoch, config, amp_run, filepath, local_ra epoch[0] = checkpoint['epoch']+1 device_id = local_rank % torch.cuda.device_count() - torch.cuda.set_rng_state(checkpoint['cuda_rng_state_all'][device_id]) + if "cuda_rng_state_all" in checkpoint: + torch.cuda.set_rng_state(checkpoint['cuda_rng_state_all'][device_id]) if 'random_rng_states_all' in checkpoint: torch.random.set_rng_state(checkpoint['random_rng_states_all'][device_id]) elif 'random_rng_state' in checkpoint: From ce34a1f1d28b26af1d35d4e9e68ab781d83252fc Mon Sep 17 00:00:00 2001 From: zach wener Date: Wed, 17 Feb 2021 17:08:47 +0000 Subject: [PATCH 09/16] freeze encoder --- PyTorch/SpeechSynthesis/Tacotron2/train.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/PyTorch/SpeechSynthesis/Tacotron2/train.py b/PyTorch/SpeechSynthesis/Tacotron2/train.py index 7119a5d04..1db8c72a8 100644 --- a/PyTorch/SpeechSynthesis/Tacotron2/train.py +++ b/PyTorch/SpeechSynthesis/Tacotron2/train.py @@ -97,6 +97,7 @@ def parse_args(parser): help='Run cudnn benchmark') training.add_argument('--disable-uniform-initialize-bn-weight', action='store_true', help='disable uniform initialization of batchnorm layer weight') + training.add_argument('--freeze-encoder', action='store_true', default=False) optimization = parser.add_argument_group('optimization setup') optimization.add_argument( @@ -450,6 +451,9 @@ def main(): num_iters = 0 model.train() + if args.freeze_encoder: + for param in model.encoder.parameters(): + param.requires_grad = False for epoch in range(start_epoch, args.epochs): torch.cuda.synchronize() From 435acecbe0bd3dc2869673c919fb3543ff83c3fe Mon Sep 17 00:00:00 2001 From: zach wener Date: Mon, 22 Feb 2021 03:09:56 +0000 Subject: [PATCH 10/16] add teacher forcing notebook --- .../Tacotron2/TeacherForcing.ipynb | 5724 +++++++++++++++++ 1 file changed, 5724 insertions(+) create mode 100644 PyTorch/SpeechSynthesis/Tacotron2/TeacherForcing.ipynb diff --git a/PyTorch/SpeechSynthesis/Tacotron2/TeacherForcing.ipynb b/PyTorch/SpeechSynthesis/Tacotron2/TeacherForcing.ipynb new file mode 100644 index 000000000..009062b2e --- /dev/null +++ b/PyTorch/SpeechSynthesis/Tacotron2/TeacherForcing.ipynb @@ -0,0 +1,5724 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "total 18G\r\n", + "4.0K drwxrwxr-x 2 ubuntu ubuntu 4.0K Feb 14 19:00 .\r\n", + "4.0K drwxrwxr-x 23 ubuntu ubuntu 4.0K Feb 15 20:08 ..\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 11:43 checkpoint_Tacotron2_1000.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 12:02 checkpoint_Tacotron2_1020.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 12:21 checkpoint_Tacotron2_1040.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 12:40 checkpoint_Tacotron2_1060.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 12:58 checkpoint_Tacotron2_1080.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 13:17 checkpoint_Tacotron2_1100.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 13:36 checkpoint_Tacotron2_1120.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 13:55 checkpoint_Tacotron2_1140.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 14:14 checkpoint_Tacotron2_1160.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 14:33 checkpoint_Tacotron2_1180.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 14:52 checkpoint_Tacotron2_1200.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 15:11 checkpoint_Tacotron2_1220.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 15:30 checkpoint_Tacotron2_1240.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 15:49 checkpoint_Tacotron2_1260.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 16:08 checkpoint_Tacotron2_1280.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 16:27 checkpoint_Tacotron2_1300.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 16:46 checkpoint_Tacotron2_1320.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 17:05 checkpoint_Tacotron2_1340.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 17:24 checkpoint_Tacotron2_1360.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 17:43 checkpoint_Tacotron2_1380.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 18:03 checkpoint_Tacotron2_1400.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 18:21 checkpoint_Tacotron2_1420.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 18:41 checkpoint_Tacotron2_1440.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 19:00 checkpoint_Tacotron2_1460.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 13 17:16 checkpoint_Tacotron2_360.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 13 17:34 checkpoint_Tacotron2_380.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 13 17:53 checkpoint_Tacotron2_400.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 13 18:11 checkpoint_Tacotron2_420.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 13 18:29 checkpoint_Tacotron2_440.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 00:43 checkpoint_Tacotron2_460.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 01:02 checkpoint_Tacotron2_480.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 01:21 checkpoint_Tacotron2_500.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 01:40 checkpoint_Tacotron2_520.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 01:58 checkpoint_Tacotron2_540.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 02:17 checkpoint_Tacotron2_560.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 02:35 checkpoint_Tacotron2_580.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 02:54 checkpoint_Tacotron2_600.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 03:13 checkpoint_Tacotron2_620.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 03:32 checkpoint_Tacotron2_640.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 03:50 checkpoint_Tacotron2_660.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 04:09 checkpoint_Tacotron2_680.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 04:28 checkpoint_Tacotron2_700.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 07:06 checkpoint_Tacotron2_720.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 07:24 checkpoint_Tacotron2_740.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 07:43 checkpoint_Tacotron2_760.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 08:02 checkpoint_Tacotron2_780.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 08:21 checkpoint_Tacotron2_800.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 08:51 checkpoint_Tacotron2_820.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 09:10 checkpoint_Tacotron2_840.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 09:29 checkpoint_Tacotron2_860.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 09:48 checkpoint_Tacotron2_880.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 10:07 checkpoint_Tacotron2_900.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 10:27 checkpoint_Tacotron2_920.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 10:46 checkpoint_Tacotron2_940.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 11:05 checkpoint_Tacotron2_960.pt\r\n", + "323M -rw-rw-r-- 1 ubuntu ubuntu 323M Feb 14 11:24 checkpoint_Tacotron2_980.pt\r\n", + " 0 lrwxrwxrwx 1 ubuntu ubuntu 28 Feb 14 19:00 checkpoint_Tacotron2_last.pt -> checkpoint_Tacotron2_1460.pt\r\n", + "7.6M -rw-rw-r-- 1 ubuntu ubuntu 7.6M Feb 14 19:03 nvlog.json\r\n" + ] + } + ], + "source": [ + "!ls -lash output_michaelrosen2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "model_config = dict(\n", + " mask_padding=True,\n", + " n_mel_channels=80,\n", + " n_symbols=148,\n", + " symbols_embedding_dim=512,\n", + " #encoder\n", + " encoder_kernel_size=5,\n", + " encoder_n_convolutions=3,\n", + " encoder_embedding_dim=512,\n", + " # attention\n", + " attention_rnn_dim=1024,\n", + " attention_dim=128,\n", + " # attention location\n", + " attention_location_n_filters=32,\n", + " attention_location_kernel_size=31,\n", + " # decoder\n", + " n_frames_per_step=1,\n", + " decoder_rnn_dim=1024,\n", + " prenet_dim=256,\n", + " max_decoder_steps=2000,\n", + " gate_threshold=0.5,\n", + " p_attention_dropout=0.1,\n", + " p_decoder_dropout=0.1,\n", + " # postnet\n", + " postnet_embedding_dim=512,\n", + " postnet_kernel_size=5,\n", + " postnet_n_convolutions=5,\n", + " decoder_no_early_stopping=False,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "import argparse\n", + "\n", + "import torch\n", + "from torch.utils.data import DataLoader\n", + "import numpy as np\n", + "\n", + "from common.utils import load_filepaths_and_text\n", + "from tacotron2.data_function import TextMelLoader, TextMelCollate, batch_to_gpu\n", + "import loss_functions\n", + "from train import parse_args as train_parse_args\n", + "\n", + "import models\n", + "from tacotron2.arg_parser import tacotron2_parser\n", + "from IPython.display import Audio\n", + "import os" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def parse_args(parser):\n", + " \"\"\"\n", + " Parse commandline arguments.\n", + " \"\"\"\n", + " parser.add_argument('--text-cleaners', nargs='*',\n", + " default=['english_cleaners'], type=str,\n", + " help='Type of text cleaners for input text')\n", + " parser.add_argument('--max-wav-value', default=32768.0, type=float,\n", + " help='Maximum audiowave value')\n", + " parser.add_argument('--sampling-rate', default=22050, type=int,\n", + " help='Sampling rate')\n", + " parser.add_argument('--filter-length', default=1024, type=int,\n", + " help='Filter length')\n", + " parser.add_argument('--hop-length', default=256, type=int,\n", + " help='Hop (stride) length')\n", + " parser.add_argument('--win-length', default=1024, type=int,\n", + " help='Window length')\n", + " parser.add_argument('--mel-fmin', default=0.0, type=float,\n", + " help='Minimum mel frequency')\n", + " parser.add_argument('--mel-fmax', default=8000.0, type=float,\n", + " help='Maximum mel frequency')\n", + " parser.add_argument('--n-mel-channels', default=80, type=int,\n", + " help='Number of bins in mel-spectrograms')\n", + "\n", + " return parser\n", + "\n", + "parser = argparse.ArgumentParser(description=\"Create mels with teacher forcing\")\n", + "parser = parse_args(parser)\n", + "#parser = train_parse_args(parser)\n", + "args = parser.parse_args([\n", + " #\"--output\", \"output\", \"--model-name\", \"Tacotron2\", \n", + " #\"--epochs\", \"100\", \"--learning-rate\", \"1e-4\",\n", + " #\"-bs\", \"10\"\n", + "])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "model = models.get_model(\"Tacotron2\", model_config, cpu_run=False)\n", + "# pretrained = torch.load(\"./output_michaelrosen2/checkpoint_Tacotron2_last.pt\")\n", + "pretrained = torch.load(\"./output_trebek/checkpoint_Tacotron2_last.pt\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "model ready\n" + ] + } + ], + "source": [ + "model.load_state_dict(pretrained[\"state_dict\"])\n", + "model.cuda()\n", + "model.eval()\n", + "print('model ready')" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# dataset_path = \"/home/ubuntu/michael-rosen/\"\n", + "# audiopaths_and_text = \"/home/ubuntu/michael-rosen/michaelrosen_only_arpa_audio_text_train_filelist.txt\"\n", + "# melpaths_and_text = \"/home/ubuntu/michael-rosen/michaelrosen_only_arpa_mel_text_train_filelist.txt\"\n", + "dataset_path = \"/home/ubuntu/trebek/\"\n", + "audiopaths_and_text = \"/home/ubuntu/trebek/trebek_only_arpa_audio_text_train_filelist.txt\"\n", + "melpaths_and_text = \"/home/ubuntu/trebek/trebek_only_arpa_mel_text_train_filelist.txt\"\n", + "melpaths_and_text_list = load_filepaths_and_text(\n", + " dataset_path, \n", + " melpaths_and_text,\n", + ")\n", + "audiopaths_and_text_list = load_filepaths_and_text(\n", + " dataset_path, \n", + " audiopaths_and_text\n", + ")\n", + "args.load_mel_from_disk = True\n", + "mel_loader = TextMelLoader(dataset_path, melpaths_and_text, args)\n", + "data_loader = DataLoader(mel_loader, collate_fn=TextMelCollate(1), batch_size=2, shuffle=False)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "trebek_1346.npy\n", + "(1, 80, 809)\n", + "trebek_543.npy\n", + "(1, 80, 526)\n", + "trebek_2390.npy\n", + "(1, 80, 386)\n", + "trebek_1002.npy\n", + "(1, 80, 365)\n", + "trebek_1695.npy\n", + "(1, 80, 782)\n", + "trebek_1125.npy\n", + "(1, 80, 688)\n", + "trebek_1376.npy\n", + "(1, 80, 683)\n", + "trebek_1618.npy\n", + "(1, 80, 391)\n", + "trebek_1773.npy\n", + "(1, 80, 619)\n", + "trebek_1594.npy\n", + "(1, 80, 321)\n", + "trebek_2116.npy\n", + "(1, 80, 597)\n", + "trebek_2507.npy\n", + "(1, 80, 331)\n", + "trebek_2097.npy\n", + "(1, 80, 686)\n", + "trebek_658.npy\n", + "(1, 80, 692)\n", + "trebek_662.npy\n", + "(1, 80, 714)\n", + "trebek_600.npy\n", + "(1, 80, 510)\n", + "trebek_2324.npy\n", + "(1, 80, 672)\n", + "trebek_1772.npy\n", + "(1, 80, 321)\n", + "trebek_2545.npy\n", + "(1, 80, 401)\n", + "trebek_2553.npy\n", + "(1, 80, 313)\n", + "trebek_1467.npy\n", + "(1, 80, 789)\n", + "trebek_1204.npy\n", + "(1, 80, 523)\n", + "trebek_1756.npy\n", + "(1, 80, 469)\n", + "trebek_2546.npy\n", + "(1, 80, 241)\n", + "trebek_76.npy\n", + "(1, 80, 727)\n", + "trebek_886.npy\n", + "(1, 80, 628)\n", + "trebek_684.npy\n", + "(1, 80, 792)\n", + "trebek_292.npy\n", + "(1, 80, 554)\n", + "trebek_269.npy\n", + "(1, 80, 900)\n", + "trebek_1461.npy\n", + "(1, 80, 579)\n", + "trebek_961.npy\n", + "(1, 80, 644)\n", + "trebek_1607.npy\n", + "(1, 80, 466)\n", + "trebek_259.npy\n", + "(1, 80, 497)\n", + "trebek_1871.npy\n", + "(1, 80, 280)\n", + "trebek_2401.npy\n", + "(1, 80, 590)\n", + "trebek_53.npy\n", + "(1, 80, 551)\n", + "trebek_647.npy\n", + "(1, 80, 779)\n", + "trebek_266.npy\n", + "(1, 80, 752)\n", + "trebek_419.npy\n", + "(1, 80, 577)\n", + "trebek_1110.npy\n", + "(1, 80, 419)\n", + "trebek_1260.npy\n", + "(1, 80, 856)\n", + "trebek_803.npy\n", + "(1, 80, 566)\n", + "trebek_1042.npy\n", + "(1, 80, 671)\n", + "trebek_1538.npy\n", + "(1, 80, 628)\n", + "trebek_633.npy\n", + "(1, 80, 668)\n", + "trebek_1502.npy\n", + "(1, 80, 704)\n", + "trebek_2445.npy\n", + "(1, 80, 817)\n", + "trebek_1926.npy\n", + "(1, 80, 615)\n", + "trebek_27.npy\n", + "(1, 80, 782)\n", + "trebek_1906.npy\n", + "(1, 80, 564)\n", + "trebek_460.npy\n", + "(1, 80, 711)\n", + "trebek_1658.npy\n", + "(1, 80, 595)\n", + "trebek_362.npy\n", + "(1, 80, 662)\n", + "trebek_1466.npy\n", + "(1, 80, 370)\n", + "trebek_36.npy\n", + "(1, 80, 805)\n", + "trebek_1484.npy\n", + "(1, 80, 580)\n", + "trebek_2431.npy\n", + "(1, 80, 615)\n", + "trebek_1599.npy\n", + "(1, 80, 494)\n", + "trebek_577.npy\n", + "(1, 80, 760)\n", + "trebek_52.npy\n", + "(1, 80, 634)\n", + "trebek_1296.npy\n", + "(1, 80, 676)\n", + "trebek_1334.npy\n", + "(1, 80, 484)\n", + "trebek_2027.npy\n", + "(1, 80, 755)\n", + "trebek_1608.npy\n", + "(1, 80, 522)\n", + "trebek_122.npy\n", + "(1, 80, 827)\n", + "trebek_2094.npy\n", + "(1, 80, 680)\n", + "trebek_295.npy\n", + "(1, 80, 658)\n", + "trebek_1294.npy\n", + "(1, 80, 342)\n", + "trebek_1304.npy\n", + "(1, 80, 587)\n", + "trebek_698.npy\n", + "(1, 80, 528)\n", + "trebek_862.npy\n", + "(1, 80, 529)\n", + "trebek_821.npy\n", + "(1, 80, 533)\n", + "trebek_1147.npy\n", + "(1, 80, 671)\n", + "trebek_558.npy\n", + "(1, 80, 530)\n", + "trebek_1998.npy\n", + "(1, 80, 640)\n", + "trebek_16.npy\n", + "(1, 80, 642)\n", + "trebek_2170.npy\n", + "(1, 80, 747)\n", + "trebek_1251.npy\n", + "(1, 80, 552)\n", + "trebek_2289.npy\n", + "(1, 80, 649)\n", + "trebek_1211.npy\n", + "(1, 80, 639)\n", + "trebek_2285.npy\n", + "(1, 80, 663)\n", + "trebek_510.npy\n", + "(1, 80, 308)\n", + "trebek_1886.npy\n", + "(1, 80, 666)\n", + "trebek_1587.npy\n", + "(1, 80, 546)\n", + "trebek_562.npy\n", + "(1, 80, 627)\n", + "trebek_1566.npy\n", + "(1, 80, 574)\n", + "trebek_37.npy\n", + "(1, 80, 887)\n", + "trebek_1840.npy\n", + "(1, 80, 655)\n", + "trebek_859.npy\n", + "(1, 80, 628)\n", + "trebek_2478.npy\n", + "(1, 80, 419)\n", + "trebek_2522.npy\n", + "(1, 80, 520)\n", + "trebek_2416.npy\n", + "(1, 80, 533)\n", + "trebek_9.npy\n", + "(1, 80, 572)\n", + "trebek_374.npy\n", + "(1, 80, 287)\n", + "trebek_2550.npy\n", + "(1, 80, 476)\n", + "trebek_2051.npy\n", + "(1, 80, 497)\n", + "trebek_753.npy\n", + "(1, 80, 770)\n", + "trebek_1019.npy\n", + "(1, 80, 699)\n", + "trebek_112.npy\n", + "(1, 80, 696)\n", + "trebek_2530.npy\n", + "(1, 80, 282)\n", + "trebek_2409.npy\n", + "(1, 80, 595)\n", + "trebek_1436.npy\n", + "(1, 80, 515)\n", + "trebek_822.npy\n", + "(1, 80, 576)\n", + "trebek_2063.npy\n", + "(1, 80, 535)\n", + "trebek_1873.npy\n", + "(1, 80, 680)\n", + "trebek_1269.npy\n", + "(1, 80, 672)\n", + "trebek_2004.npy\n", + "(1, 80, 476)\n", + "trebek_1432.npy\n", + "(1, 80, 370)\n", + "trebek_1447.npy\n", + "(1, 80, 383)\n", + "trebek_1634.npy\n", + "(1, 80, 303)\n", + "trebek_2349.npy\n", + "(1, 80, 851)\n", + "trebek_657.npy\n", + "(1, 80, 535)\n", + "trebek_2519.npy\n", + "(1, 80, 546)\n", + "trebek_2468.npy\n", + "(1, 80, 329)\n", + "trebek_243.npy\n", + "(1, 80, 900)\n", + "trebek_222.npy\n", + "(1, 80, 551)\n", + "trebek_435.npy\n", + "(1, 80, 326)\n", + "trebek_2191.npy\n", + "(1, 80, 179)\n", + "trebek_405.npy\n", + "(1, 80, 569)\n", + "trebek_2267.npy\n", + "(1, 80, 362)\n", + "trebek_2424.npy\n", + "(1, 80, 541)\n", + "trebek_2454.npy\n", + "(1, 80, 145)\n", + "trebek_2016.npy\n", + "(1, 80, 727)\n", + "trebek_118.npy\n", + "(1, 80, 608)\n", + "trebek_757.npy\n", + "(1, 80, 508)\n", + "trebek_1655.npy\n", + "(1, 80, 455)\n", + "trebek_1816.npy\n", + "(1, 80, 562)\n", + "trebek_2121.npy\n", + "(1, 80, 486)\n", + "trebek_262.npy\n", + "(1, 80, 905)\n", + "trebek_31.npy\n", + "(1, 80, 944)\n", + "trebek_1289.npy\n", + "(1, 80, 771)\n", + "trebek_1617.npy\n", + "(1, 80, 368)\n", + "trebek_1264.npy\n", + "(1, 80, 621)\n", + "trebek_1881.npy\n", + "(1, 80, 559)\n", + "trebek_953.npy\n", + "(1, 80, 750)\n", + "trebek_795.npy\n", + "(1, 80, 238)\n", + "trebek_2203.npy\n", + "(1, 80, 698)\n", + "trebek_2003.npy\n", + "(1, 80, 378)\n", + "trebek_1081.npy\n", + "(1, 80, 758)\n", + "trebek_231.npy\n", + "(1, 80, 339)\n", + "trebek_2554.npy\n", + "(1, 80, 574)\n", + "trebek_1439.npy\n", + "(1, 80, 205)\n", + "trebek_1819.npy\n", + "(1, 80, 572)\n", + "trebek_1640.npy\n", + "(1, 80, 530)\n", + "trebek_1453.npy\n", + "(1, 80, 556)\n", + "trebek_1838.npy\n", + "(1, 80, 329)\n", + "trebek_999.npy\n", + "(1, 80, 561)\n", + "trebek_2291.npy\n", + "(1, 80, 459)\n", + "trebek_320.npy\n", + "(1, 80, 831)\n", + "trebek_288.npy\n", + "(1, 80, 430)\n", + "trebek_2484.npy\n", + "(1, 80, 584)\n", + "trebek_2327.npy\n", + "(1, 80, 666)\n", + "trebek_585.npy\n", + "(1, 80, 719)\n", + "trebek_1649.npy\n", + "(1, 80, 474)\n", + "trebek_546.npy\n", + "(1, 80, 714)\n", + "trebek_2347.npy\n", + "(1, 80, 603)\n", + "trebek_240.npy\n", + "(1, 80, 758)\n", + "trebek_830.npy\n", + "(1, 80, 605)\n", + "trebek_1766.npy\n", + "(1, 80, 787)\n", + "trebek_1190.npy\n", + "(1, 80, 658)\n", + "trebek_2523.npy\n", + "(1, 80, 476)\n", + "trebek_1638.npy\n", + "(1, 80, 393)\n", + "trebek_1320.npy\n", + "(1, 80, 566)\n", + "trebek_182.npy\n", + "(1, 80, 272)\n", + "trebek_678.npy\n", + "(1, 80, 590)\n", + "trebek_1956.npy\n", + "(1, 80, 432)\n", + "trebek_956.npy\n", + "(1, 80, 618)\n", + "trebek_1478.npy\n", + "(1, 80, 649)\n", + "trebek_524.npy\n", + "(1, 80, 650)\n", + "trebek_1138.npy\n", + "(1, 80, 581)\n", + "trebek_935.npy\n", + "(1, 80, 730)\n", + "trebek_2088.npy\n", + "(1, 80, 564)\n", + "trebek_626.npy\n", + "(1, 80, 585)\n", + "trebek_1677.npy\n", + "(1, 80, 339)\n", + "trebek_1580.npy\n", + "(1, 80, 518)\n", + "trebek_1637.npy\n", + "(1, 80, 556)\n", + "trebek_1273.npy\n", + "(1, 80, 628)\n", + "trebek_1628.npy\n", + "(1, 80, 564)\n", + "trebek_2253.npy\n", + "(1, 80, 667)\n", + "trebek_2421.npy\n", + "(1, 80, 551)\n", + "trebek_285.npy\n", + "(1, 80, 489)\n", + "trebek_233.npy\n", + "(1, 80, 445)\n", + "trebek_68.npy\n", + "(1, 80, 727)\n", + "trebek_1463.npy\n", + "(1, 80, 370)\n", + "trebek_2411.npy\n", + "(1, 80, 712)\n", + "trebek_1652.npy\n", + "(1, 80, 249)\n", + "trebek_642.npy\n", + "(1, 80, 779)\n", + "trebek_581.npy\n", + "(1, 80, 721)\n", + "trebek_2014.npy\n", + "(1, 80, 732)\n", + "trebek_1398.npy\n", + "(1, 80, 616)\n", + "trebek_773.npy\n", + "(1, 80, 486)\n", + "trebek_1855.npy\n", + "(1, 80, 471)\n", + "trebek_855.npy\n", + "(1, 80, 696)\n", + "trebek_181.npy\n", + "(1, 80, 644)\n", + "trebek_1924.npy\n", + "(1, 80, 665)\n", + "trebek_2374.npy\n", + "(1, 80, 504)\n", + "trebek_40.npy\n", + "(1, 80, 538)\n", + "trebek_44.npy\n", + "(1, 80, 510)\n", + "trebek_1548.npy\n", + "(1, 80, 639)\n", + "trebek_430.npy\n", + "(1, 80, 595)\n", + "trebek_1137.npy\n", + "(1, 80, 657)\n", + "trebek_2050.npy\n", + "(1, 80, 479)\n", + "trebek_2284.npy\n", + "(1, 80, 347)\n", + "trebek_2406.npy\n", + "(1, 80, 264)\n", + "trebek_712.npy\n", + "(1, 80, 738)\n", + "trebek_1219.npy\n", + "(1, 80, 443)\n", + "trebek_1073.npy\n", + "(1, 80, 740)\n", + "trebek_348.npy\n", + "(1, 80, 535)\n", + "trebek_256.npy\n", + "(1, 80, 590)\n", + "trebek_1144.npy\n", + "(1, 80, 743)\n", + "trebek_436.npy\n", + "(1, 80, 577)\n", + "trebek_86.npy\n", + "(1, 80, 450)\n", + "trebek_852.npy\n", + "(1, 80, 631)\n", + "trebek_2492.npy\n", + "(1, 80, 512)\n", + "trebek_397.npy\n", + "(1, 80, 601)\n", + "trebek_615.npy\n", + "(1, 80, 510)\n", + "trebek_851.npy\n", + "(1, 80, 549)\n", + "trebek_2174.npy\n", + "(1, 80, 557)\n", + "trebek_1099.npy\n", + "(1, 80, 702)\n", + "trebek_104.npy\n", + "(1, 80, 460)\n", + "trebek_2189.npy\n", + "(1, 80, 621)\n", + "trebek_1904.npy\n", + "(1, 80, 538)\n", + "trebek_1159.npy\n", + "(1, 80, 610)\n", + "trebek_843.npy\n", + "(1, 80, 724)\n", + "trebek_507.npy\n", + "(1, 80, 753)\n", + "trebek_2117.npy\n", + "(1, 80, 533)\n", + "trebek_503.npy\n", + "(1, 80, 663)\n", + "trebek_1744.npy\n", + "(1, 80, 192)\n", + "trebek_762.npy\n", + "(1, 80, 706)\n", + "trebek_2373.npy\n", + "(1, 80, 507)\n", + "trebek_1844.npy\n", + "(1, 80, 707)\n", + "trebek_165.npy\n", + "(1, 80, 427)\n", + "trebek_1851.npy\n", + "(1, 80, 698)\n", + "trebek_1817.npy\n", + "(1, 80, 546)\n", + "trebek_537.npy\n", + "(1, 80, 895)\n", + "trebek_2176.npy\n", + "(1, 80, 696)\n", + "trebek_424.npy\n", + "(1, 80, 747)\n", + "trebek_138.npy\n", + "(1, 80, 724)\n", + "trebek_2494.npy\n", + "(1, 80, 446)\n", + "trebek_769.npy\n", + "(1, 80, 500)\n", + "trebek_2036.npy\n", + "(1, 80, 559)\n", + "trebek_2261.npy\n", + "(1, 80, 401)\n", + "trebek_142.npy\n", + "(1, 80, 626)\n", + "trebek_780.npy\n", + "(1, 80, 427)\n", + "trebek_1825.npy\n", + "(1, 80, 639)\n", + "trebek_325.npy\n", + "(1, 80, 536)\n", + "trebek_468.npy\n", + "(1, 80, 950)\n", + "trebek_2297.npy\n", + "(1, 80, 267)\n", + "trebek_2247.npy\n", + "(1, 80, 694)\n", + "trebek_1990.npy\n", + "(1, 80, 517)\n", + "trebek_293.npy\n", + "(1, 80, 840)\n", + "trebek_1040.npy\n", + "(1, 80, 758)\n", + "trebek_2045.npy\n", + "(1, 80, 716)\n", + "trebek_467.npy\n", + "(1, 80, 683)\n", + "trebek_1987.npy\n", + "(1, 80, 823)\n", + "trebek_2221.npy\n", + "(1, 80, 566)\n", + "trebek_2162.npy\n", + "(1, 80, 592)\n", + "trebek_779.npy\n", + "(1, 80, 409)\n", + "trebek_2019.npy\n", + "(1, 80, 709)\n", + "trebek_594.npy\n", + "(1, 80, 383)\n", + "trebek_1035.npy\n", + "(1, 80, 569)\n", + "trebek_2236.npy\n", + "(1, 80, 228)\n", + "trebek_2222.npy\n", + "(1, 80, 583)\n", + "trebek_2498.npy\n", + "(1, 80, 228)\n", + "trebek_2331.npy\n", + "(1, 80, 675)\n", + "trebek_1916.npy\n", + "(1, 80, 437)\n", + "trebek_2087.npy\n", + "(1, 80, 569)\n", + "trebek_776.npy\n", + "(1, 80, 580)\n", + "trebek_1091.npy\n", + "(1, 80, 760)\n", + "trebek_5.npy\n", + "(1, 80, 631)\n", + "trebek_2276.npy\n", + "(1, 80, 789)\n", + "trebek_153.npy\n", + "(1, 80, 786)\n", + "trebek_2001.npy\n", + "(1, 80, 595)\n", + "trebek_10.npy\n", + "(1, 80, 489)\n", + "trebek_1511.npy\n", + "(1, 80, 771)\n", + "trebek_1542.npy\n", + "(1, 80, 732)\n", + "trebek_646.npy\n", + "(1, 80, 796)\n", + "trebek_2169.npy\n", + "(1, 80, 479)\n", + "trebek_560.npy\n", + "(1, 80, 833)\n", + "trebek_630.npy\n", + "(1, 80, 536)\n", + "trebek_407.npy\n", + "(1, 80, 835)\n", + "trebek_117.npy\n", + "(1, 80, 932)\n", + "trebek_730.npy\n", + "(1, 80, 685)\n", + "trebek_1518.npy\n", + "(1, 80, 411)\n", + "trebek_2282.npy\n", + "(1, 80, 626)\n", + "trebek_1070.npy\n", + "(1, 80, 479)\n", + "trebek_872.npy\n", + "(1, 80, 596)\n", + "trebek_78.npy\n", + "(1, 80, 688)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "trebek_433.npy\n", + "(1, 80, 825)\n", + "trebek_2463.npy\n", + "(1, 80, 272)\n", + "trebek_1185.npy\n", + "(1, 80, 709)\n", + "trebek_1066.npy\n", + "(1, 80, 618)\n", + "trebek_719.npy\n", + "(1, 80, 637)\n", + "trebek_2385.npy\n", + "(1, 80, 422)\n", + "trebek_709.npy\n", + "(1, 80, 380)\n", + "trebek_2560.npy\n", + "(1, 80, 318)\n", + "trebek_341.npy\n", + "(1, 80, 645)\n", + "trebek_1493.npy\n", + "(1, 80, 471)\n", + "trebek_607.npy\n", + "(1, 80, 670)\n", + "trebek_1043.npy\n", + "(1, 80, 507)\n", + "trebek_518.npy\n", + "(1, 80, 691)\n", + "trebek_2302.npy\n", + "(1, 80, 380)\n", + "trebek_39.npy\n", + "(1, 80, 1036)\n", + "trebek_1808.npy\n", + "(1, 80, 298)\n", + "trebek_1234.npy\n", + "(1, 80, 745)\n", + "trebek_2486.npy\n", + "(1, 80, 471)\n", + "trebek_71.npy\n", + "(1, 80, 920)\n", + "trebek_635.npy\n", + "(1, 80, 750)\n", + "trebek_1212.npy\n", + "(1, 80, 526)\n", + "trebek_1041.npy\n", + "(1, 80, 440)\n", + "trebek_327.npy\n", + "(1, 80, 786)\n", + "trebek_2314.npy\n", + "(1, 80, 597)\n", + "trebek_1516.npy\n", + "(1, 80, 672)\n", + "trebek_1799.npy\n", + "(1, 80, 504)\n", + "trebek_1176.npy\n", + "(1, 80, 668)\n", + "trebek_1833.npy\n", + "(1, 80, 510)\n", + "trebek_2326.npy\n", + "(1, 80, 713)\n", + "trebek_270.npy\n", + "(1, 80, 432)\n", + "trebek_720.npy\n", + "(1, 80, 796)\n", + "trebek_338.npy\n", + "(1, 80, 509)\n", + "trebek_213.npy\n", + "(1, 80, 694)\n", + "trebek_125.npy\n", + "(1, 80, 639)\n", + "trebek_367.npy\n", + "(1, 80, 650)\n", + "trebek_329.npy\n", + "(1, 80, 628)\n", + "trebek_481.npy\n", + "(1, 80, 755)\n", + "trebek_309.npy\n", + "(1, 80, 538)\n", + "trebek_1328.npy\n", + "(1, 80, 572)\n", + "trebek_1752.npy\n", + "(1, 80, 417)\n", + "trebek_1900.npy\n", + "(1, 80, 647)\n", + "trebek_1366.npy\n", + "(1, 80, 376)\n", + "trebek_416.npy\n", + "(1, 80, 760)\n", + "trebek_1743.npy\n", + "(1, 80, 689)\n", + "trebek_1648.npy\n", + "(1, 80, 701)\n", + "trebek_699.npy\n", + "(1, 80, 362)\n", + "trebek_343.npy\n", + "(1, 80, 584)\n", + "trebek_566.npy\n", + "(1, 80, 500)\n", + "trebek_1586.npy\n", + "(1, 80, 577)\n", + "trebek_345.npy\n", + "(1, 80, 336)\n", + "trebek_88.npy\n", + "(1, 80, 671)\n", + "trebek_1874.npy\n", + "(1, 80, 683)\n", + "trebek_997.npy\n", + "(1, 80, 615)\n", + "trebek_1707.npy\n", + "(1, 80, 486)\n", + "trebek_2064.npy\n", + "(1, 80, 665)\n", + "trebek_2317.npy\n", + "(1, 80, 603)\n", + "trebek_2033.npy\n", + "(1, 80, 724)\n", + "trebek_985.npy\n", + "(1, 80, 489)\n", + "trebek_871.npy\n", + "(1, 80, 856)\n", + "trebek_192.npy\n", + "(1, 80, 574)\n", + "trebek_1646.npy\n", + "(1, 80, 528)\n", + "trebek_726.npy\n", + "(1, 80, 473)\n", + "trebek_734.npy\n", + "(1, 80, 572)\n", + "trebek_1031.npy\n", + "(1, 80, 484)\n", + "trebek_1694.npy\n", + "(1, 80, 776)\n", + "trebek_2474.npy\n", + "(1, 80, 569)\n", + "trebek_155.npy\n", + "(1, 80, 508)\n", + "trebek_1864.npy\n", + "(1, 80, 274)\n", + "trebek_1853.npy\n", + "(1, 80, 608)\n", + "trebek_969.npy\n", + "(1, 80, 517)\n", + "trebek_443.npy\n", + "(1, 80, 641)\n", + "trebek_1848.npy\n", + "(1, 80, 357)\n", + "trebek_422.npy\n", + "(1, 80, 502)\n", + "trebek_1008.npy\n", + "(1, 80, 557)\n", + "trebek_1452.npy\n", + "(1, 80, 662)\n", + "trebek_399.npy\n", + "(1, 80, 450)\n", + "trebek_1733.npy\n", + "(1, 80, 640)\n", + "trebek_1105.npy\n", + "(1, 80, 367)\n", + "trebek_2480.npy\n", + "(1, 80, 464)\n", + "trebek_427.npy\n", + "(1, 80, 508)\n", + "trebek_2229.npy\n", + "(1, 80, 561)\n", + "trebek_996.npy\n", + "(1, 80, 277)\n", + "trebek_355.npy\n", + "(1, 80, 743)\n", + "trebek_1957.npy\n", + "(1, 80, 212)\n", + "trebek_1479.npy\n", + "(1, 80, 835)\n", + "trebek_1115.npy\n", + "(1, 80, 267)\n", + "trebek_2009.npy\n", + "(1, 80, 605)\n", + "trebek_346.npy\n", + "(1, 80, 502)\n", + "trebek_2238.npy\n", + "(1, 80, 696)\n", + "trebek_2525.npy\n", + "(1, 80, 197)\n", + "trebek_64.npy\n", + "(1, 80, 844)\n", + "trebek_439.npy\n", + "(1, 80, 440)\n", + "trebek_965.npy\n", + "(1, 80, 748)\n", + "trebek_1249.npy\n", + "(1, 80, 628)\n", + "trebek_791.npy\n", + "(1, 80, 448)\n", + "trebek_798.npy\n", + "(1, 80, 303)\n", + "trebek_1059.npy\n", + "(1, 80, 608)\n", + "trebek_2049.npy\n", + "(1, 80, 438)\n", + "trebek_1314.npy\n", + "(1, 80, 535)\n", + "trebek_1764.npy\n", + "(1, 80, 644)\n", + "trebek_166.npy\n", + "(1, 80, 644)\n", + "trebek_2372.npy\n", + "(1, 80, 375)\n", + "trebek_591.npy\n", + "(1, 80, 592)\n", + "trebek_2464.npy\n", + "(1, 80, 218)\n", + "trebek_1198.npy\n", + "(1, 80, 600)\n", + "trebek_1241.npy\n", + "(1, 80, 531)\n", + "trebek_1194.npy\n", + "(1, 80, 737)\n", + "trebek_351.npy\n", + "(1, 80, 590)\n", + "trebek_2558.npy\n", + "(1, 80, 587)\n", + "trebek_224.npy\n", + "(1, 80, 479)\n", + "trebek_1920.npy\n", + "(1, 80, 662)\n", + "trebek_1221.npy\n", + "(1, 80, 584)\n", + "trebek_2335.npy\n", + "(1, 80, 804)\n", + "trebek_2044.npy\n", + "(1, 80, 680)\n", + "trebek_557.npy\n", + "(1, 80, 693)\n", + "trebek_263.npy\n", + "(1, 80, 657)\n", + "trebek_1791.npy\n", + "(1, 80, 662)\n", + "trebek_1657.npy\n", + "(1, 80, 565)\n", + "trebek_1202.npy\n", + "(1, 80, 565)\n", + "trebek_1239.npy\n", + "(1, 80, 544)\n", + "trebek_986.npy\n", + "(1, 80, 709)\n", + "trebek_475.npy\n", + "(1, 80, 590)\n", + "trebek_1996.npy\n", + "(1, 80, 432)\n", + "trebek_1836.npy\n", + "(1, 80, 499)\n", + "trebek_1448.npy\n", + "(1, 80, 624)\n", + "trebek_2080.npy\n", + "(1, 80, 700)\n", + "trebek_1195.npy\n", + "(1, 80, 644)\n", + "trebek_2055.npy\n", + "(1, 80, 261)\n", + "trebek_639.npy\n", + "(1, 80, 771)\n", + "trebek_573.npy\n", + "(1, 80, 450)\n", + "trebek_232.npy\n", + "(1, 80, 698)\n", + "trebek_725.npy\n", + "(1, 80, 640)\n", + "trebek_732.npy\n", + "(1, 80, 835)\n", + "trebek_2488.npy\n", + "(1, 80, 566)\n", + "trebek_1577.npy\n", + "(1, 80, 650)\n", + "trebek_1626.npy\n", + "(1, 80, 228)\n", + "trebek_1598.npy\n", + "(1, 80, 678)\n", + "trebek_2429.npy\n", + "(1, 80, 381)\n", + "trebek_864.npy\n", + "(1, 80, 727)\n", + "trebek_2085.npy\n", + "(1, 80, 727)\n", + "trebek_922.npy\n", + "(1, 80, 621)\n", + "trebek_66.npy\n", + "(1, 80, 562)\n", + "trebek_670.npy\n", + "(1, 80, 688)\n", + "trebek_2156.npy\n", + "(1, 80, 453)\n", + "trebek_2487.npy\n", + "(1, 80, 501)\n", + "trebek_1934.npy\n", + "(1, 80, 468)\n", + "trebek_94.npy\n", + "(1, 80, 675)\n", + "trebek_652.npy\n", + "(1, 80, 440)\n", + "trebek_2277.npy\n", + "(1, 80, 603)\n", + "trebek_1267.npy\n", + "(1, 80, 481)\n", + "trebek_1017.npy\n", + "(1, 80, 592)\n", + "trebek_579.npy\n", + "(1, 80, 490)\n", + "trebek_1560.npy\n", + "(1, 80, 590)\n", + "trebek_673.npy\n", + "(1, 80, 476)\n", + "trebek_1805.npy\n", + "(1, 80, 805)\n", + "trebek_2073.npy\n", + "(1, 80, 497)\n", + "trebek_1378.npy\n", + "(1, 80, 551)\n", + "trebek_1537.npy\n", + "(1, 80, 636)\n", + "trebek_2521.npy\n", + "(1, 80, 684)\n", + "trebek_1639.npy\n", + "(1, 80, 255)\n", + "trebek_2440.npy\n", + "(1, 80, 622)\n", + "trebek_1476.npy\n", + "(1, 80, 538)\n", + "trebek_2448.npy\n", + "(1, 80, 566)\n", + "trebek_185.npy\n", + "(1, 80, 471)\n", + "trebek_784.npy\n", + "(1, 80, 634)\n", + "trebek_245.npy\n", + "(1, 80, 614)\n", + "trebek_159.npy\n", + "(1, 80, 641)\n", + "trebek_1152.npy\n", + "(1, 80, 582)\n", + "trebek_146.npy\n", + "(1, 80, 657)\n", + "trebek_2028.npy\n", + "(1, 80, 473)\n", + "trebek_2180.npy\n", + "(1, 80, 419)\n", + "trebek_1253.npy\n", + "(1, 80, 357)\n", + "trebek_2007.npy\n", + "(1, 80, 755)\n", + "trebek_1036.npy\n", + "(1, 80, 672)\n", + "trebek_1274.npy\n", + "(1, 80, 636)\n", + "trebek_2295.npy\n", + "(1, 80, 702)\n", + "trebek_1357.npy\n", + "(1, 80, 665)\n", + "trebek_145.npy\n", + "(1, 80, 517)\n", + "trebek_2422.npy\n", + "(1, 80, 559)\n", + "trebek_2386.npy\n", + "(1, 80, 380)\n", + "trebek_1867.npy\n", + "(1, 80, 569)\n", + "trebek_994.npy\n", + "(1, 80, 336)\n", + "trebek_458.npy\n", + "(1, 80, 698)\n", + "trebek_2439.npy\n", + "(1, 80, 541)\n", + "trebek_2265.npy\n", + "(1, 80, 652)\n", + "trebek_2017.npy\n", + "(1, 80, 680)\n", + "trebek_1814.npy\n", + "(1, 80, 706)\n", + "trebek_184.npy\n", + "(1, 80, 572)\n", + "trebek_1922.npy\n", + "(1, 80, 654)\n", + "trebek_794.npy\n", + "(1, 80, 517)\n", + "trebek_1277.npy\n", + "(1, 80, 548)\n", + "trebek_120.npy\n", + "(1, 80, 479)\n", + "trebek_2472.npy\n", + "(1, 80, 473)\n", + "trebek_604.npy\n", + "(1, 80, 393)\n", + "trebek_1341.npy\n", + "(1, 80, 900)\n", + "trebek_669.npy\n", + "(1, 80, 588)\n", + "trebek_491.npy\n", + "(1, 80, 652)\n", + "trebek_2131.npy\n", + "(1, 80, 652)\n", + "trebek_1213.npy\n", + "(1, 80, 672)\n", + "trebek_1032.npy\n", + "(1, 80, 566)\n", + "trebek_1435.npy\n", + "(1, 80, 473)\n", + "trebek_1919.npy\n", + "(1, 80, 461)\n", + "trebek_2339.npy\n", + "(1, 80, 719)\n", + "trebek_1324.npy\n", + "(1, 80, 631)\n", + "trebek_307.npy\n", + "(1, 80, 843)\n", + "trebek_2220.npy\n", + "(1, 80, 530)\n", + "trebek_324.npy\n", + "(1, 80, 756)\n", + "trebek_2371.npy\n", + "(1, 80, 398)\n", + "trebek_455.npy\n", + "(1, 80, 907)\n", + "trebek_2555.npy\n", + "(1, 80, 298)\n", + "trebek_1593.npy\n", + "(1, 80, 615)\n", + "trebek_1675.npy\n", + "(1, 80, 689)\n", + "trebek_1647.npy\n", + "(1, 80, 623)\n", + "trebek_1624.npy\n", + "(1, 80, 584)\n", + "trebek_1312.npy\n", + "(1, 80, 699)\n", + "trebek_1385.npy\n", + "(1, 80, 409)\n", + "trebek_2511.npy\n", + "(1, 80, 659)\n", + "trebek_428.npy\n", + "(1, 80, 590)\n", + "trebek_2541.npy\n", + "(1, 80, 417)\n", + "trebek_2436.npy\n", + "(1, 80, 424)\n", + "trebek_1055.npy\n", + "(1, 80, 553)\n", + "trebek_2346.npy\n", + "(1, 80, 293)\n", + "trebek_87.npy\n", + "(1, 80, 610)\n", + "trebek_918.npy\n", + "(1, 80, 507)\n", + "trebek_522.npy\n", + "(1, 80, 763)\n", + "trebek_478.npy\n", + "(1, 80, 714)\n", + "trebek_1815.npy\n", + "(1, 80, 587)\n", + "trebek_1523.npy\n", + "(1, 80, 560)\n", + "trebek_943.npy\n", + "(1, 80, 502)\n", + "trebek_878.npy\n", + "(1, 80, 445)\n", + "trebek_102.npy\n", + "(1, 80, 541)\n", + "trebek_1909.npy\n", + "(1, 80, 440)\n", + "trebek_847.npy\n", + "(1, 80, 758)\n", + "trebek_1897.npy\n", + "(1, 80, 740)\n", + "trebek_2337.npy\n", + "(1, 80, 745)\n", + "trebek_2062.npy\n", + "(1, 80, 560)\n", + "trebek_1984.npy\n", + "(1, 80, 720)\n", + "trebek_2184.npy\n", + "(1, 80, 673)\n", + "trebek_332.npy\n", + "(1, 80, 595)\n", + "trebek_1261.npy\n", + "(1, 80, 564)\n", + "trebek_417.npy\n", + "(1, 80, 491)\n", + "trebek_2452.npy\n", + "(1, 80, 313)\n", + "trebek_275.npy\n", + "(1, 80, 615)\n", + "trebek_799.npy\n", + "(1, 80, 419)\n", + "trebek_2270.npy\n", + "(1, 80, 746)\n", + "trebek_1392.npy\n", + "(1, 80, 631)\n", + "trebek_56.npy\n", + "(1, 80, 734)\n", + "trebek_2345.npy\n", + "(1, 80, 404)\n", + "trebek_437.npy\n", + "(1, 80, 631)\n", + "trebek_1262.npy\n", + "(1, 80, 378)\n", + "trebek_2163.npy\n", + "(1, 80, 701)\n", + "trebek_1205.npy\n", + "(1, 80, 559)\n", + "trebek_1372.npy\n", + "(1, 80, 709)\n", + "trebek_2128.npy\n", + "(1, 80, 422)\n", + "trebek_1368.npy\n", + "(1, 80, 670)\n", + "trebek_2415.npy\n", + "(1, 80, 490)\n", + "trebek_1006.npy\n", + "(1, 80, 732)\n", + "trebek_1584.npy\n", + "(1, 80, 487)\n", + "trebek_384.npy\n", + "(1, 80, 553)\n", + "trebek_801.npy\n", + "(1, 80, 471)\n", + "trebek_1653.npy\n", + "(1, 80, 575)\n", + "trebek_2533.npy\n", + "(1, 80, 367)\n", + "trebek_2035.npy\n", + "(1, 80, 681)\n", + "trebek_792.npy\n", + "(1, 80, 616)\n", + "trebek_1189.npy\n", + "(1, 80, 584)\n", + "trebek_1100.npy\n", + "(1, 80, 639)\n", + "trebek_770.npy\n", + "(1, 80, 750)\n", + "trebek_2005.npy\n", + "(1, 80, 522)\n", + "trebek_1293.npy\n", + "(1, 80, 632)\n", + "trebek_147.npy\n", + "(1, 80, 595)\n", + "trebek_1485.npy\n", + "(1, 80, 812)\n", + "trebek_1865.npy\n", + "(1, 80, 300)\n", + "trebek_824.npy\n", + "(1, 80, 634)\n", + "trebek_587.npy\n", + "(1, 80, 663)\n", + "trebek_493.npy\n", + "(1, 80, 603)\n", + "trebek_955.npy\n", + "(1, 80, 595)\n", + "trebek_178.npy\n", + "(1, 80, 572)\n", + "trebek_2559.npy\n", + "(1, 80, 339)\n", + "trebek_168.npy\n", + "(1, 80, 675)\n", + "trebek_237.npy\n", + "(1, 80, 497)\n", + "trebek_4.npy\n", + "(1, 80, 614)\n", + "trebek_1716.npy\n", + "(1, 80, 435)\n", + "trebek_2268.npy\n", + "(1, 80, 696)\n", + "trebek_1925.npy\n", + "(1, 80, 458)\n", + "trebek_2520.npy\n", + "(1, 80, 714)\n", + "trebek_2499.npy\n", + "(1, 80, 396)\n", + "trebek_2234.npy\n", + "(1, 80, 492)\n", + "trebek_1014.npy\n", + "(1, 80, 463)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "trebek_668.npy\n", + "(1, 80, 755)\n", + "trebek_1994.npy\n", + "(1, 80, 554)\n", + "trebek_1222.npy\n", + "(1, 80, 711)\n", + "trebek_793.npy\n", + "(1, 80, 572)\n", + "trebek_1444.npy\n", + "(1, 80, 728)\n", + "trebek_1475.npy\n", + "(1, 80, 654)\n", + "trebek_2078.npy\n", + "(1, 80, 603)\n", + "trebek_1403.npy\n", + "(1, 80, 473)\n", + "trebek_1092.npy\n", + "(1, 80, 601)\n", + "trebek_2497.npy\n", + "(1, 80, 409)\n", + "trebek_1116.npy\n", + "(1, 80, 572)\n", + "trebek_729.npy\n", + "(1, 80, 482)\n", + "trebek_1899.npy\n", + "(1, 80, 771)\n", + "trebek_2093.npy\n", + "(1, 80, 477)\n", + "trebek_268.npy\n", + "(1, 80, 810)\n", + "trebek_2086.npy\n", + "(1, 80, 567)\n", + "trebek_1578.npy\n", + "(1, 80, 577)\n", + "trebek_1044.npy\n", + "(1, 80, 432)\n", + "trebek_2338.npy\n", + "(1, 80, 690)\n", + "trebek_1986.npy\n", + "(1, 80, 450)\n", + "trebek_1330.npy\n", + "(1, 80, 471)\n", + "trebek_1308.npy\n", + "(1, 80, 340)\n", + "trebek_1969.npy\n", + "(1, 80, 639)\n", + "trebek_1474.npy\n", + "(1, 80, 533)\n", + "trebek_54.npy\n", + "(1, 80, 422)\n", + "trebek_1161.npy\n", + "(1, 80, 318)\n", + "trebek_889.npy\n", + "(1, 80, 729)\n", + "trebek_214.npy\n", + "(1, 80, 786)\n", + "trebek_931.npy\n", + "(1, 80, 608)\n", + "trebek_521.npy\n", + "(1, 80, 492)\n", + "trebek_1576.npy\n", + "(1, 80, 628)\n", + "trebek_1450.npy\n", + "(1, 80, 587)\n", + "trebek_1776.npy\n", + "(1, 80, 522)\n", + "trebek_979.npy\n", + "(1, 80, 499)\n", + "trebek_1268.npy\n", + "(1, 80, 564)\n", + "trebek_957.npy\n", + "(1, 80, 479)\n", + "trebek_1270.npy\n", + "(1, 80, 584)\n", + "trebek_1282.npy\n", + "(1, 80, 456)\n", + "trebek_2294.npy\n", + "(1, 80, 644)\n", + "trebek_2235.npy\n", + "(1, 80, 551)\n", + "trebek_411.npy\n", + "(1, 80, 572)\n", + "trebek_2398.npy\n", + "(1, 80, 564)\n", + "trebek_1145.npy\n", + "(1, 80, 709)\n", + "trebek_829.npy\n", + "(1, 80, 615)\n", + "trebek_723.npy\n", + "(1, 80, 690)\n", + "trebek_2466.npy\n", + "(1, 80, 455)\n", + "trebek_1895.npy\n", + "(1, 80, 652)\n", + "trebek_907.npy\n", + "(1, 80, 636)\n", + "trebek_1946.npy\n", + "(1, 80, 771)\n", + "trebek_1021.npy\n", + "(1, 80, 683)\n", + "trebek_1490.npy\n", + "(1, 80, 632)\n", + "trebek_333.npy\n", + "(1, 80, 569)\n", + "trebek_515.npy\n", + "(1, 80, 813)\n", + "trebek_1785.npy\n", + "(1, 80, 564)\n", + "trebek_624.npy\n", + "(1, 80, 497)\n", + "trebek_1411.npy\n", + "(1, 80, 336)\n", + "trebek_1688.npy\n", + "(1, 80, 758)\n", + "trebek_463.npy\n", + "(1, 80, 721)\n", + "trebek_46.npy\n", + "(1, 80, 799)\n", + "trebek_2237.npy\n", + "(1, 80, 230)\n", + "trebek_2256.npy\n", + "(1, 80, 406)\n", + "trebek_1954.npy\n", + "(1, 80, 296)\n", + "trebek_2433.npy\n", + "(1, 80, 646)\n", + "trebek_1755.npy\n", + "(1, 80, 579)\n", + "trebek_1446.npy\n", + "(1, 80, 750)\n", + "trebek_1449.npy\n", + "(1, 80, 666)\n", + "trebek_1049.npy\n", + "(1, 80, 781)\n", + "trebek_1180.npy\n", + "(1, 80, 693)\n", + "trebek_2410.npy\n", + "(1, 80, 696)\n", + "trebek_1514.npy\n", + "(1, 80, 688)\n", + "trebek_1892.npy\n", + "(1, 80, 704)\n", + "trebek_364.npy\n", + "(1, 80, 601)\n", + "trebek_1148.npy\n", + "(1, 80, 727)\n", + "trebek_2026.npy\n", + "(1, 80, 686)\n", + "trebek_1146.npy\n", + "(1, 80, 502)\n", + "trebek_1419.npy\n", + "(1, 80, 414)\n", + "trebek_568.npy\n", + "(1, 80, 424)\n", + "trebek_1973.npy\n", + "(1, 80, 280)\n", + "trebek_473.npy\n", + "(1, 80, 548)\n", + "trebek_616.npy\n", + "(1, 80, 445)\n", + "trebek_128.npy\n", + "(1, 80, 655)\n", + "trebek_1666.npy\n", + "(1, 80, 592)\n", + "trebek_2061.npy\n", + "(1, 80, 517)\n", + "trebek_1164.npy\n", + "(1, 80, 398)\n", + "trebek_2360.npy\n", + "(1, 80, 489)\n", + "trebek_1238.npy\n", + "(1, 80, 406)\n", + "trebek_1602.npy\n", + "(1, 80, 791)\n", + "trebek_1086.npy\n", + "(1, 80, 609)\n", + "trebek_201.npy\n", + "(1, 80, 693)\n", + "trebek_339.npy\n", + "(1, 80, 422)\n", + "trebek_844.npy\n", + "(1, 80, 606)\n", + "trebek_1117.npy\n", + "(1, 80, 615)\n", + "trebek_820.npy\n", + "(1, 80, 579)\n", + "trebek_2451.npy\n", + "(1, 80, 456)\n", + "trebek_1321.npy\n", + "(1, 80, 827)\n", + "trebek_1569.npy\n", + "(1, 80, 611)\n", + "trebek_2293.npy\n", + "(1, 80, 546)\n", + "trebek_893.npy\n", + "(1, 80, 587)\n", + "trebek_2490.npy\n", + "(1, 80, 665)\n", + "trebek_111.npy\n", + "(1, 80, 549)\n", + "trebek_12.npy\n", + "(1, 80, 497)\n", + "trebek_2133.npy\n", + "(1, 80, 422)\n", + "trebek_469.npy\n", + "(1, 80, 869)\n", + "trebek_2102.npy\n", + "(1, 80, 448)\n", + "trebek_1323.npy\n", + "(1, 80, 835)\n", + "trebek_1517.npy\n", + "(1, 80, 610)\n", + "trebek_55.npy\n", + "(1, 80, 693)\n", + "trebek_1197.npy\n", + "(1, 80, 564)\n", + "trebek_1425.npy\n", + "(1, 80, 683)\n", + "trebek_1861.npy\n", + "(1, 80, 618)\n", + "trebek_360.npy\n", + "(1, 80, 771)\n", + "trebek_462.npy\n", + "(1, 80, 363)\n", + "trebek_304.npy\n", + "(1, 80, 835)\n", + "trebek_2444.npy\n", + "(1, 80, 645)\n", + "trebek_1673.npy\n", + "(1, 80, 634)\n", + "trebek_1469.npy\n", + "(1, 80, 623)\n", + "trebek_91.npy\n", + "(1, 80, 543)\n", + "trebek_1410.npy\n", + "(1, 80, 371)\n", + "trebek_317.npy\n", + "(1, 80, 647)\n", + "trebek_1427.npy\n", + "(1, 80, 329)\n", + "trebek_1443.npy\n", + "(1, 80, 747)\n", + "trebek_2442.npy\n", + "(1, 80, 437)\n", + "trebek_1632.npy\n", + "(1, 80, 742)\n", + "trebek_448.npy\n", + "(1, 80, 574)\n", + "trebek_48.npy\n", + "(1, 80, 771)\n", + "trebek_1823.npy\n", + "(1, 80, 621)\n", + "trebek_1888.npy\n", + "(1, 80, 848)\n", + "trebek_1332.npy\n", + "(1, 80, 477)\n", + "trebek_2262.npy\n", + "(1, 80, 481)\n", + "trebek_1642.npy\n", + "(1, 80, 466)\n", + "trebek_1342.npy\n", + "(1, 80, 681)\n", + "trebek_2561.npy\n", + "(1, 80, 603)\n", + "trebek_1266.npy\n", + "(1, 80, 561)\n", + "trebek_756.npy\n", + "(1, 80, 491)\n", + "trebek_206.npy\n", + "(1, 80, 608)\n", + "trebek_1604.npy\n", + "(1, 80, 507)\n", + "trebek_2458.npy\n", + "(1, 80, 383)\n", + "trebek_1421.npy\n", + "(1, 80, 469)\n", + "trebek_837.npy\n", + "(1, 80, 800)\n", + "trebek_1363.npy\n", + "(1, 80, 502)\n", + "trebek_252.npy\n", + "(1, 80, 649)\n", + "trebek_2134.npy\n", + "(1, 80, 438)\n", + "trebek_2274.npy\n", + "(1, 80, 810)\n", + "trebek_1183.npy\n", + "(1, 80, 518)\n", + "trebek_2110.npy\n", + "(1, 80, 442)\n", + "trebek_710.npy\n", + "(1, 80, 422)\n", + "trebek_2046.npy\n", + "(1, 80, 611)\n", + "trebek_1845.npy\n", + "(1, 80, 432)\n", + "trebek_2122.npy\n", + "(1, 80, 728)\n", + "trebek_766.npy\n", + "(1, 80, 590)\n", + "trebek_1735.npy\n", + "(1, 80, 615)\n", + "trebek_1472.npy\n", + "(1, 80, 639)\n", + "trebek_991.npy\n", + "(1, 80, 674)\n", + "trebek_1.npy\n", + "(1, 80, 628)\n", + "trebek_1989.npy\n", + "(1, 80, 724)\n", + "trebek_826.npy\n", + "(1, 80, 460)\n", + "trebek_1244.npy\n", + "(1, 80, 784)\n", + "trebek_484.npy\n", + "(1, 80, 585)\n", + "trebek_2153.npy\n", + "(1, 80, 671)\n", + "trebek_1917.npy\n", + "(1, 80, 685)\n", + "trebek_1554.npy\n", + "(1, 80, 704)\n", + "trebek_2065.npy\n", + "(1, 80, 491)\n", + "trebek_322.npy\n", + "(1, 80, 864)\n", + "trebek_1506.npy\n", + "(1, 80, 491)\n", + "trebek_702.npy\n", + "(1, 80, 820)\n", + "trebek_1422.npy\n", + "(1, 80, 533)\n", + "trebek_1591.npy\n", + "(1, 80, 758)\n", + "trebek_1254.npy\n", + "(1, 80, 401)\n", + "trebek_440.npy\n", + "(1, 80, 714)\n", + "trebek_1220.npy\n", + "(1, 80, 502)\n", + "trebek_1826.npy\n", + "(1, 80, 714)\n", + "trebek_174.npy\n", + "(1, 80, 577)\n", + "trebek_674.npy\n", + "(1, 80, 497)\n", + "trebek_1709.npy\n", + "(1, 80, 425)\n", + "trebek_1806.npy\n", + "(1, 80, 701)\n", + "trebek_570.npy\n", + "(1, 80, 347)\n", + "trebek_2245.npy\n", + "(1, 80, 781)\n", + "trebek_2364.npy\n", + "(1, 80, 344)\n", + "trebek_2512.npy\n", + "(1, 80, 541)\n", + "trebek_884.npy\n", + "(1, 80, 502)\n", + "trebek_1740.npy\n", + "(1, 80, 641)\n", + "trebek_2408.npy\n", + "(1, 80, 559)\n", + "trebek_1525.npy\n", + "(1, 80, 362)\n", + "trebek_2503.npy\n", + "(1, 80, 502)\n", + "trebek_24.npy\n", + "(1, 80, 543)\n", + "trebek_1402.npy\n", + "(1, 80, 445)\n", + "trebek_239.npy\n", + "(1, 80, 735)\n", + "trebek_2032.npy\n", + "(1, 80, 712)\n", + "trebek_1736.npy\n", + "(1, 80, 704)\n", + "trebek_1679.npy\n", + "(1, 80, 432)\n", + "trebek_2459.npy\n", + "(1, 80, 388)\n", + "trebek_982.npy\n", + "(1, 80, 342)\n", + "trebek_618.npy\n", + "(1, 80, 468)\n", + "trebek_2183.npy\n", + "(1, 80, 199)\n", + "trebek_208.npy\n", + "(1, 80, 719)\n", + "trebek_1150.npy\n", + "(1, 80, 440)\n", + "trebek_347.npy\n", + "(1, 80, 758)\n", + "trebek_1595.npy\n", + "(1, 80, 548)\n", + "trebek_2412.npy\n", + "(1, 80, 582)\n", + "trebek_908.npy\n", + "(1, 80, 528)\n", + "trebek_1547.npy\n", + "(1, 80, 696)\n", + "trebek_43.npy\n", + "(1, 80, 680)\n", + "trebek_992.npy\n", + "(1, 80, 776)\n", + "trebek_140.npy\n", + "(1, 80, 484)\n", + "trebek_1079.npy\n", + "(1, 80, 691)\n", + "trebek_1714.npy\n", + "(1, 80, 267)\n", + "trebek_2287.npy\n", + "(1, 80, 649)\n", + "trebek_228.npy\n", + "(1, 80, 476)\n", + "trebek_73.npy\n", + "(1, 80, 810)\n", + "trebek_1420.npy\n", + "(1, 80, 652)\n", + "trebek_2039.npy\n", + "(1, 80, 686)\n", + "trebek_863.npy\n", + "(1, 80, 628)\n", + "trebek_974.npy\n", + "(1, 80, 685)\n", + "trebek_1011.npy\n", + "(1, 80, 719)\n", + "trebek_896.npy\n", + "(1, 80, 670)\n", + "trebek_1847.npy\n", + "(1, 80, 355)\n", + "trebek_617.npy\n", + "(1, 80, 626)\n", + "trebek_298.npy\n", + "(1, 80, 355)\n", + "trebek_380.npy\n", + "(1, 80, 662)\n", + "trebek_1275.npy\n", + "(1, 80, 645)\n", + "trebek_2052.npy\n", + "(1, 80, 657)\n", + "trebek_2232.npy\n", + "(1, 80, 473)\n", + "trebek_835.npy\n", + "(1, 80, 584)\n", + "trebek_1977.npy\n", + "(1, 80, 520)\n", + "trebek_1672.npy\n", + "(1, 80, 538)\n", + "trebek_131.npy\n", + "(1, 80, 653)\n", + "trebek_2155.npy\n", + "(1, 80, 641)\n", + "trebek_497.npy\n", + "(1, 80, 538)\n", + "trebek_2437.npy\n", + "(1, 80, 610)\n", + "trebek_149.npy\n", + "(1, 80, 597)\n", + "trebek_1075.npy\n", + "(1, 80, 676)\n", + "trebek_1574.npy\n", + "(1, 80, 658)\n", + "trebek_891.npy\n", + "(1, 80, 827)\n", + "trebek_2400.npy\n", + "(1, 80, 641)\n", + "trebek_287.npy\n", + "(1, 80, 683)\n", + "trebek_90.npy\n", + "(1, 80, 515)\n", + "trebek_2272.npy\n", + "(1, 80, 716)\n", + "trebek_2224.npy\n", + "(1, 80, 386)\n", + "trebek_1970.npy\n", + "(1, 80, 671)\n", + "trebek_205.npy\n", + "(1, 80, 662)\n", + "trebek_1299.npy\n", + "(1, 80, 618)\n", + "trebek_2329.npy\n", + "(1, 80, 639)\n", + "trebek_2149.npy\n", + "(1, 80, 698)\n", + "trebek_1883.npy\n", + "(1, 80, 616)\n", + "trebek_1697.npy\n", + "(1, 80, 595)\n", + "trebek_1811.npy\n", + "(1, 80, 538)\n", + "trebek_2396.npy\n", + "(1, 80, 458)\n", + "trebek_894.npy\n", + "(1, 80, 417)\n", + "trebek_294.npy\n", + "(1, 80, 605)\n", + "trebek_1750.npy\n", + "(1, 80, 324)\n", + "trebek_2435.npy\n", + "(1, 80, 600)\n", + "trebek_1830.npy\n", + "(1, 80, 572)\n", + "trebek_952.npy\n", + "(1, 80, 773)\n", + "trebek_1961.npy\n", + "(1, 80, 233)\n", + "trebek_599.npy\n", + "(1, 80, 652)\n", + "trebek_1670.npy\n", + "(1, 80, 409)\n", + "trebek_2322.npy\n", + "(1, 80, 711)\n", + "trebek_853.npy\n", + "(1, 80, 610)\n", + "trebek_331.npy\n", + "(1, 80, 424)\n", + "trebek_1798.npy\n", + "(1, 80, 337)\n", + "trebek_2266.npy\n", + "(1, 80, 683)\n", + "trebek_1121.npy\n", + "(1, 80, 709)\n", + "trebek_193.npy\n", + "(1, 80, 733)\n", + "trebek_580.npy\n", + "(1, 80, 380)\n", + "trebek_2308.npy\n", + "(1, 80, 402)\n", + "trebek_1953.npy\n", + "(1, 80, 321)\n", + "trebek_2286.npy\n", + "(1, 80, 778)\n", + "trebek_2096.npy\n", + "(1, 80, 520)\n", + "trebek_727.npy\n", + "(1, 80, 574)\n", + "trebek_377.npy\n", + "(1, 80, 484)\n", + "trebek_1846.npy\n", + "(1, 80, 396)\n", + "trebek_2413.npy\n", + "(1, 80, 280)\n", + "trebek_2119.npy\n", + "(1, 80, 611)\n", + "trebek_2465.npy\n", + "(1, 80, 295)\n", + "trebek_2070.npy\n", + "(1, 80, 502)\n", + "trebek_2132.npy\n", + "(1, 80, 393)\n", + "trebek_2060.npy\n", + "(1, 80, 584)\n", + "trebek_1000.npy\n", + "(1, 80, 492)\n", + "trebek_1803.npy\n", + "(1, 80, 574)\n", + "trebek_1754.npy\n", + "(1, 80, 530)\n", + "trebek_368.npy\n", + "(1, 80, 670)\n", + "trebek_1193.npy\n", + "(1, 80, 616)\n", + "trebek_353.npy\n", + "(1, 80, 838)\n", + "trebek_1708.npy\n", + "(1, 80, 311)\n", + "trebek_848.npy\n", + "(1, 80, 290)\n", + "trebek_1424.npy\n", + "(1, 80, 264)\n", + "trebek_1399.npy\n", + "(1, 80, 835)\n", + "trebek_1793.npy\n", + "(1, 80, 642)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "trebek_2333.npy\n", + "(1, 80, 591)\n", + "trebek_2473.npy\n", + "(1, 80, 342)\n", + "trebek_1119.npy\n", + "(1, 80, 653)\n", + "trebek_1890.npy\n", + "(1, 80, 690)\n", + "trebek_1782.npy\n", + "(1, 80, 685)\n", + "trebek_2352.npy\n", + "(1, 80, 476)\n", + "trebek_1543.npy\n", + "(1, 80, 690)\n", + "trebek_1944.npy\n", + "(1, 80, 745)\n", + "trebek_1386.npy\n", + "(1, 80, 548)\n", + "trebek_1233.npy\n", + "(1, 80, 399)\n", + "trebek_1405.npy\n", + "(1, 80, 809)\n", + "trebek_2330.npy\n", + "(1, 80, 531)\n", + "trebek_805.npy\n", + "(1, 80, 603)\n", + "trebek_151.npy\n", + "(1, 80, 513)\n", + "trebek_771.npy\n", + "(1, 80, 719)\n", + "trebek_743.npy\n", + "(1, 80, 381)\n", + "trebek_2084.npy\n", + "(1, 80, 858)\n", + "trebek_2112.npy\n", + "(1, 80, 704)\n", + "trebek_701.npy\n", + "(1, 80, 931)\n", + "trebek_1069.npy\n", + "(1, 80, 564)\n", + "trebek_83.npy\n", + "(1, 80, 740)\n", + "trebek_1322.npy\n", + "(1, 80, 614)\n", + "trebek_746.npy\n", + "(1, 80, 623)\n", + "trebek_1656.npy\n", + "(1, 80, 569)\n", + "trebek_2551.npy\n", + "(1, 80, 546)\n", + "trebek_2188.npy\n", + "(1, 80, 671)\n", + "trebek_2092.npy\n", + "(1, 80, 468)\n", + "trebek_103.npy\n", + "(1, 80, 342)\n", + "trebek_1729.npy\n", + "(1, 80, 572)\n", + "trebek_2402.npy\n", + "(1, 80, 295)\n", + "trebek_1513.npy\n", + "(1, 80, 610)\n", + "trebek_2223.npy\n", + "(1, 80, 481)\n", + "trebek_2428.npy\n", + "(1, 80, 641)\n", + "trebek_744.npy\n", + "(1, 80, 628)\n", + "trebek_1383.npy\n", + "(1, 80, 651)\n", + "trebek_1377.npy\n", + "(1, 80, 455)\n", + "trebek_2562.npy\n", + "(1, 80, 900)\n", + "trebek_819.npy\n", + "(1, 80, 518)\n", + "trebek_1286.npy\n", + "(1, 80, 686)\n", + "trebek_1382.npy\n", + "(1, 80, 533)\n", + "trebek_1790.npy\n", + "(1, 80, 603)\n", + "trebek_2214.npy\n", + "(1, 80, 316)\n", + "trebek_1114.npy\n", + "(1, 80, 752)\n", + "trebek_129.npy\n", + "(1, 80, 703)\n", + "trebek_528.npy\n", + "(1, 80, 619)\n", + "trebek_2251.npy\n", + "(1, 80, 419)\n", + "trebek_811.npy\n", + "(1, 80, 804)\n", + "trebek_1522.npy\n", + "(1, 80, 460)\n", + "trebek_1033.npy\n", + "(1, 80, 634)\n", + "trebek_1809.npy\n", + "(1, 80, 513)\n", + "trebek_2425.npy\n", + "(1, 80, 486)\n", + "trebek_38.npy\n", + "(1, 80, 497)\n", + "trebek_890.npy\n", + "(1, 80, 503)\n", + "trebek_625.npy\n", + "(1, 80, 466)\n", + "trebek_253.npy\n", + "(1, 80, 693)\n", + "trebek_980.npy\n", + "(1, 80, 548)\n", + "trebek_378.npy\n", + "(1, 80, 640)\n", + "trebek_2334.npy\n", + "(1, 80, 189)\n", + "trebek_1023.npy\n", + "(1, 80, 554)\n", + "trebek_697.npy\n", + "(1, 80, 406)\n", + "trebek_1704.npy\n", + "(1, 80, 773)\n", + "trebek_858.npy\n", + "(1, 80, 691)\n", + "trebek_968.npy\n", + "(1, 80, 663)\n", + "trebek_2531.npy\n", + "(1, 80, 299)\n", + "trebek_1781.npy\n", + "(1, 80, 641)\n", + "trebek_2000.npy\n", + "(1, 80, 404)\n", + "trebek_2447.npy\n", + "(1, 80, 704)\n", + "trebek_1992.npy\n", + "(1, 80, 659)\n", + "trebek_471.npy\n", + "(1, 80, 712)\n", + "trebek_1157.npy\n", + "(1, 80, 473)\n", + "trebek_887.npy\n", + "(1, 80, 867)\n", + "trebek_754.npy\n", + "(1, 80, 668)\n", + "trebek_461.npy\n", + "(1, 80, 822)\n", + "trebek_2404.npy\n", + "(1, 80, 269)\n", + "trebek_1563.npy\n", + "(1, 80, 794)\n", + "trebek_278.npy\n", + "(1, 80, 805)\n", + "trebek_67.npy\n", + "(1, 80, 865)\n", + "trebek_945.npy\n", + "(1, 80, 396)\n", + "trebek_1078.npy\n", + "(1, 80, 683)\n", + "trebek_152.npy\n", + "(1, 80, 512)\n", + "trebek_418.npy\n", + "(1, 80, 577)\n", + "trebek_191.npy\n", + "(1, 80, 522)\n", + "trebek_1943.npy\n", + "(1, 80, 685)\n", + "trebek_1769.npy\n", + "(1, 80, 529)\n", + "trebek_1807.npy\n", + "(1, 80, 737)\n", + "trebek_2058.npy\n", + "(1, 80, 305)\n", + "trebek_681.npy\n", + "(1, 80, 662)\n", + "trebek_2534.npy\n", + "(1, 80, 404)\n", + "trebek_611.npy\n", + "(1, 80, 849)\n", + "trebek_485.npy\n", + "(1, 80, 626)\n", + "trebek_2047.npy\n", + "(1, 80, 742)\n", + "trebek_747.npy\n", + "(1, 80, 593)\n", + "trebek_1486.npy\n", + "(1, 80, 740)\n", + "trebek_1611.npy\n", + "(1, 80, 521)\n", + "trebek_1300.npy\n", + "(1, 80, 751)\n", + "trebek_1283.npy\n", + "(1, 80, 683)\n", + "trebek_1387.npy\n", + "(1, 80, 668)\n", + "trebek_2142.npy\n", + "(1, 80, 440)\n", + "trebek_25.npy\n", + "(1, 80, 714)\n", + "trebek_656.npy\n", + "(1, 80, 502)\n", + "trebek_2259.npy\n", + "(1, 80, 622)\n", + "trebek_450.npy\n", + "(1, 80, 564)\n", + "trebek_1462.npy\n", + "(1, 80, 751)\n", + "trebek_286.npy\n", + "(1, 80, 587)\n", + "trebek_2517.npy\n", + "(1, 80, 322)\n", + "trebek_2206.npy\n", + "(1, 80, 388)\n", + "trebek_30.npy\n", + "(1, 80, 782)\n", + "trebek_1730.npy\n", + "(1, 80, 652)\n", + "trebek_1696.npy\n", + "(1, 80, 615)\n", + "trebek_1096.npy\n", + "(1, 80, 628)\n", + "trebek_1483.npy\n", + "(1, 80, 729)\n", + "trebek_1434.npy\n", + "(1, 80, 494)\n", + "trebek_1417.npy\n", + "(1, 80, 531)\n", + "trebek_2106.npy\n", + "(1, 80, 639)\n", + "trebek_1389.npy\n", + "(1, 80, 721)\n", + "trebek_1468.npy\n", + "(1, 80, 577)\n", + "trebek_1887.npy\n", + "(1, 80, 708)\n", + "trebek_904.npy\n", + "(1, 80, 621)\n", + "trebek_2246.npy\n", + "(1, 80, 644)\n", + "trebek_1246.npy\n", + "(1, 80, 600)\n", + "trebek_716.npy\n", + "(1, 80, 510)\n", + "trebek_486.npy\n", + "(1, 80, 386)\n", + "trebek_221.npy\n", + "(1, 80, 680)\n", + "trebek_1028.npy\n", + "(1, 80, 592)\n", + "trebek_47.npy\n", + "(1, 80, 541)\n", + "trebek_489.npy\n", + "(1, 80, 388)\n", + "trebek_1016.npy\n", + "(1, 80, 615)\n", + "trebek_1949.npy\n", + "(1, 80, 601)\n", + "trebek_216.npy\n", + "(1, 80, 665)\n", + "trebek_1746.npy\n", + "(1, 80, 298)\n", + "trebek_2025.npy\n", + "(1, 80, 768)\n", + "trebek_724.npy\n", + "(1, 80, 610)\n", + "trebek_1111.npy\n", + "(1, 80, 645)\n", + "trebek_680.npy\n", + "(1, 80, 317)\n", + "trebek_938.npy\n", + "(1, 80, 609)\n", + "trebek_1530.npy\n", + "(1, 80, 324)\n", + "trebek_1380.npy\n", + "(1, 80, 517)\n", + "trebek_1533.npy\n", + "(1, 80, 397)\n", + "trebek_1339.npy\n", + "(1, 80, 671)\n", + "trebek_1668.npy\n", + "(1, 80, 535)\n", + "trebek_15.npy\n", + "(1, 80, 547)\n", + "trebek_1971.npy\n", + "(1, 80, 543)\n", + "trebek_576.npy\n", + "(1, 80, 512)\n", + "trebek_1379.npy\n", + "(1, 80, 469)\n", + "trebek_65.npy\n", + "(1, 80, 732)\n", + "trebek_1362.npy\n", + "(1, 80, 640)\n", + "trebek_496.npy\n", + "(1, 80, 765)\n", + "trebek_1571.npy\n", + "(1, 80, 274)\n", + "trebek_2430.npy\n", + "(1, 80, 639)\n", + "trebek_777.npy\n", + "(1, 80, 556)\n", + "trebek_504.npy\n", + "(1, 80, 435)\n", + "trebek_856.npy\n", + "(1, 80, 280)\n", + "trebek_1371.npy\n", + "(1, 80, 740)\n", + "trebek_1991.npy\n", + "(1, 80, 678)\n", + "trebek_768.npy\n", + "(1, 80, 623)\n", + "trebek_2369.npy\n", + "(1, 80, 696)\n", + "trebek_352.npy\n", + "(1, 80, 601)\n", + "trebek_1255.npy\n", + "(1, 80, 425)\n", + "trebek_28.npy\n", + "(1, 80, 747)\n", + "trebek_629.npy\n", + "(1, 80, 466)\n", + "trebek_459.npy\n", + "(1, 80, 787)\n", + "trebek_1026.npy\n", + "(1, 80, 686)\n", + "trebek_1558.npy\n", + "(1, 80, 535)\n", + "trebek_1644.npy\n", + "(1, 80, 260)\n", + "trebek_1359.npy\n", + "(1, 80, 486)\n", + "trebek_655.npy\n", + "(1, 80, 552)\n", + "trebek_1301.npy\n", + "(1, 80, 719)\n", + "trebek_408.npy\n", + "(1, 80, 512)\n", + "trebek_2509.npy\n", + "(1, 80, 782)\n", + "trebek_426.npy\n", + "(1, 80, 362)\n", + "trebek_645.npy\n", + "(1, 80, 758)\n", + "trebek_940.npy\n", + "(1, 80, 569)\n", + "trebek_903.npy\n", + "(1, 80, 530)\n", + "trebek_2483.npy\n", + "(1, 80, 365)\n", + "trebek_1179.npy\n", + "(1, 80, 624)\n", + "trebek_1913.npy\n", + "(1, 80, 515)\n", + "trebek_1087.npy\n", + "(1, 80, 639)\n", + "trebek_136.npy\n", + "(1, 80, 596)\n", + "trebek_410.npy\n", + "(1, 80, 833)\n", + "trebek_337.npy\n", + "(1, 80, 410)\n", + "trebek_1939.npy\n", + "(1, 80, 593)\n", + "trebek_1336.npy\n", + "(1, 80, 606)\n", + "trebek_109.npy\n", + "(1, 80, 685)\n", + "trebek_874.npy\n", + "(1, 80, 535)\n", + "trebek_209.npy\n", + "(1, 80, 605)\n", + "trebek_1610.npy\n", + "(1, 80, 316)\n", + "trebek_973.npy\n", + "(1, 80, 926)\n", + "trebek_1160.npy\n", + "(1, 80, 386)\n", + "trebek_909.npy\n", + "(1, 80, 734)\n", + "trebek_1120.npy\n", + "(1, 80, 502)\n", + "trebek_371.npy\n", + "(1, 80, 658)\n", + "trebek_592.npy\n", + "(1, 80, 522)\n", + "trebek_1801.npy\n", + "(1, 80, 592)\n", + "trebek_797.npy\n", + "(1, 80, 314)\n", + "trebek_382.npy\n", + "(1, 80, 565)\n", + "trebek_578.npy\n", + "(1, 80, 225)\n", + "trebek_2011.npy\n", + "(1, 80, 719)\n", + "trebek_613.npy\n", + "(1, 80, 659)\n", + "trebek_135.npy\n", + "(1, 80, 985)\n", + "trebek_315.npy\n", + "(1, 80, 709)\n", + "trebek_721.npy\n", + "(1, 80, 760)\n", + "trebek_2547.npy\n", + "(1, 80, 410)\n", + "trebek_2336.npy\n", + "(1, 80, 711)\n", + "trebek_2209.npy\n", + "(1, 80, 549)\n", + "trebek_267.npy\n", + "(1, 80, 864)\n", + "trebek_2377.npy\n", + "(1, 80, 520)\n", + "trebek_82.npy\n", + "(1, 80, 856)\n", + "trebek_1139.npy\n", + "(1, 80, 495)\n", + "trebek_2136.npy\n", + "(1, 80, 680)\n", + "trebek_2482.npy\n", + "(1, 80, 342)\n", + "trebek_261.npy\n", + "(1, 80, 569)\n", + "trebek_2557.npy\n", + "(1, 80, 187)\n", + "trebek_42.npy\n", + "(1, 80, 990)\n", + "trebek_45.npy\n", + "(1, 80, 791)\n", + "trebek_1149.npy\n", + "(1, 80, 590)\n", + "trebek_695.npy\n", + "(1, 80, 419)\n", + "trebek_1329.npy\n", + "(1, 80, 657)\n", + "trebek_1678.npy\n", + "(1, 80, 365)\n", + "trebek_1567.npy\n", + "(1, 80, 760)\n", + "trebek_683.npy\n", + "(1, 80, 409)\n", + "trebek_1131.npy\n", + "(1, 80, 683)\n", + "trebek_2476.npy\n", + "(1, 80, 442)\n", + "trebek_1230.npy\n", + "(1, 80, 670)\n", + "trebek_2168.npy\n", + "(1, 80, 579)\n", + "trebek_1701.npy\n", + "(1, 80, 473)\n", + "trebek_0.npy\n", + "(1, 80, 541)\n", + "trebek_1870.npy\n", + "(1, 80, 618)\n", + "trebek_686.npy\n", + "(1, 80, 502)\n", + "trebek_49.npy\n", + "(1, 80, 820)\n", + "trebek_650.npy\n", + "(1, 80, 587)\n", + "trebek_2307.npy\n", + "(1, 80, 584)\n", + "trebek_328.npy\n", + "(1, 80, 654)\n", + "trebek_396.npy\n", + "(1, 80, 522)\n", + "trebek_96.npy\n", + "(1, 80, 591)\n", + "trebek_144.npy\n", + "(1, 80, 652)\n", + "trebek_861.npy\n", + "(1, 80, 578)\n", + "trebek_519.npy\n", + "(1, 80, 845)\n", + "trebek_1082.npy\n", + "(1, 80, 425)\n", + "trebek_640.npy\n", + "(1, 80, 675)\n", + "trebek_183.npy\n", + "(1, 80, 468)\n", + "trebek_589.npy\n", + "(1, 80, 613)\n", + "trebek_376.npy\n", + "(1, 80, 636)\n", + "trebek_1236.npy\n", + "(1, 80, 574)\n", + "trebek_663.npy\n", + "(1, 80, 595)\n", + "trebek_582.npy\n", + "(1, 80, 564)\n", + "trebek_1409.npy\n", + "(1, 80, 398)\n", + "trebek_319.npy\n", + "(1, 80, 860)\n", + "trebek_35.npy\n", + "(1, 80, 442)\n", + "trebek_1217.npy\n", + "(1, 80, 701)\n", + "trebek_786.npy\n", + "(1, 80, 639)\n", + "trebek_100.npy\n", + "(1, 80, 577)\n", + "trebek_2264.npy\n", + "(1, 80, 555)\n", + "trebek_194.npy\n", + "(1, 80, 776)\n", + "trebek_1551.npy\n", + "(1, 80, 259)\n", + "trebek_742.npy\n", + "(1, 80, 615)\n", + "trebek_2370.npy\n", + "(1, 80, 205)\n", + "trebek_1630.npy\n", + "(1, 80, 497)\n", + "trebek_1168.npy\n", + "(1, 80, 486)\n", + "trebek_1582.npy\n", + "(1, 80, 737)\n", + "trebek_1052.npy\n", + "(1, 80, 584)\n", + "trebek_1257.npy\n", + "(1, 80, 600)\n", + "trebek_246.npy\n", + "(1, 80, 574)\n", + "trebek_834.npy\n", + "(1, 80, 857)\n", + "trebek_1930.npy\n", + "(1, 80, 515)\n", + "trebek_1689.npy\n", + "(1, 80, 631)\n", + "trebek_565.npy\n", + "(1, 80, 373)\n", + "trebek_1141.npy\n", + "(1, 80, 561)\n", + "trebek_2208.npy\n", + "(1, 80, 249)\n", + "trebek_924.npy\n", + "(1, 80, 636)\n", + "trebek_1831.npy\n", + "(1, 80, 584)\n", + "trebek_545.npy\n", + "(1, 80, 732)\n", + "trebek_1813.npy\n", + "(1, 80, 567)\n", + "trebek_2538.npy\n", + "(1, 80, 502)\n", + "trebek_2391.npy\n", + "(1, 80, 414)\n", + "trebek_22.npy\n", + "(1, 80, 814)\n", + "trebek_2344.npy\n", + "(1, 80, 414)\n", + "trebek_966.npy\n", + "(1, 80, 931)\n", + "trebek_735.npy\n", + "(1, 80, 634)\n", + "trebek_1457.npy\n", + "(1, 80, 590)\n", + "trebek_2356.npy\n", + "(1, 80, 533)\n", + "trebek_1979.npy\n", + "(1, 80, 719)\n", + "trebek_1911.npy\n", + "(1, 80, 507)\n", + "trebek_1053.npy\n", + "(1, 80, 727)\n", + "trebek_1199.npy\n", + "(1, 80, 649)\n", + "trebek_2477.npy\n", + "(1, 80, 466)\n", + "trebek_2366.npy\n", + "(1, 80, 515)\n", + "trebek_1126.npy\n", + "(1, 80, 577)\n", + "trebek_514.npy\n", + "(1, 80, 453)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "trebek_910.npy\n", + "(1, 80, 406)\n", + "trebek_1113.npy\n", + "(1, 80, 261)\n", + "trebek_1596.npy\n", + "(1, 80, 560)\n", + "trebek_1433.npy\n", + "(1, 80, 349)\n", + "trebek_1123.npy\n", + "(1, 80, 615)\n", + "trebek_1524.npy\n", + "(1, 80, 342)\n", + "trebek_1247.npy\n", + "(1, 80, 549)\n", + "trebek_627.npy\n", + "(1, 80, 541)\n", + "trebek_1592.npy\n", + "(1, 80, 681)\n", + "trebek_2165.npy\n", + "(1, 80, 641)\n", + "trebek_495.npy\n", + "(1, 80, 686)\n", + "trebek_1025.npy\n", + "(1, 80, 644)\n", + "trebek_340.npy\n", + "(1, 80, 584)\n", + "trebek_369.npy\n", + "(1, 80, 442)\n", + "trebek_1488.npy\n", + "(1, 80, 871)\n", + "trebek_722.npy\n", + "(1, 80, 598)\n", + "trebek_1622.npy\n", + "(1, 80, 530)\n", + "trebek_1863.npy\n", + "(1, 80, 466)\n", + "trebek_1214.npy\n", + "(1, 80, 479)\n", + "trebek_596.npy\n", + "(1, 80, 476)\n", + "trebek_2212.npy\n", + "(1, 80, 521)\n", + "trebek_603.npy\n", + "(1, 80, 414)\n", + "trebek_541.npy\n", + "(1, 80, 597)\n", + "trebek_2292.npy\n", + "(1, 80, 577)\n", + "trebek_800.npy\n", + "(1, 80, 427)\n", + "trebek_2535.npy\n", + "(1, 80, 352)\n", + "trebek_972.npy\n", + "(1, 80, 635)\n", + "trebek_841.npy\n", + "(1, 80, 525)\n", + "trebek_1491.npy\n", + "(1, 80, 794)\n", + "trebek_1203.npy\n", + "(1, 80, 556)\n", + "trebek_1849.npy\n", + "(1, 80, 632)\n", + "trebek_2423.npy\n", + "(1, 80, 610)\n", + "trebek_1822.npy\n", + "(1, 80, 603)\n", + "trebek_311.npy\n", + "(1, 80, 582)\n", + "trebek_6.npy\n", + "(1, 80, 900)\n", + "trebek_812.npy\n", + "(1, 80, 627)\n", + "trebek_1975.npy\n", + "(1, 80, 714)\n", + "trebek_914.npy\n", + "(1, 80, 393)\n", + "trebek_199.npy\n", + "(1, 80, 709)\n", + "trebek_947.npy\n", + "(1, 80, 504)\n", + "trebek_244.npy\n", + "(1, 80, 517)\n", + "trebek_691.npy\n", + "(1, 80, 414)\n", + "trebek_1659.npy\n", + "(1, 80, 740)\n", + "trebek_689.npy\n", + "(1, 80, 547)\n", + "trebek_2090.npy\n", + "(1, 80, 647)\n", + "trebek_1156.npy\n", + "(1, 80, 551)\n", + "trebek_202.npy\n", + "(1, 80, 569)\n", + "trebek_2089.npy\n", + "(1, 80, 497)\n", + "trebek_899.npy\n", + "(1, 80, 665)\n", + "trebek_2502.npy\n", + "(1, 80, 520)\n", + "trebek_479.npy\n", + "(1, 80, 714)\n", + "trebek_934.npy\n", + "(1, 80, 626)\n", + "trebek_873.npy\n", + "(1, 80, 771)\n", + "trebek_2081.npy\n", + "(1, 80, 621)\n", + "trebek_1030.npy\n", + "(1, 80, 446)\n", + "trebek_513.npy\n", + "(1, 80, 386)\n", + "trebek_1726.npy\n", + "(1, 80, 815)\n", + "trebek_2426.npy\n", + "(1, 80, 587)\n", + "trebek_2145.npy\n", + "(1, 80, 681)\n", + "trebek_1903.npy\n", + "(1, 80, 424)\n", + "trebek_1703.npy\n", + "(1, 80, 802)\n", + "trebek_218.npy\n", + "(1, 80, 608)\n", + "trebek_2564.npy\n", + "(1, 80, 491)\n", + "trebek_879.npy\n", + "(1, 80, 485)\n", + "trebek_920.npy\n", + "(1, 80, 659)\n", + "trebek_500.npy\n", + "(1, 80, 380)\n", + "trebek_1745.npy\n", + "(1, 80, 773)\n", + "trebek_1133.npy\n", + "(1, 80, 520)\n", + "trebek_682.npy\n", + "(1, 80, 584)\n", + "trebek_693.npy\n", + "(1, 80, 468)\n", + "trebek_2450.npy\n", + "(1, 80, 678)\n", + "trebek_1438.npy\n", + "(1, 80, 380)\n", + "trebek_2368.npy\n", + "(1, 80, 742)\n", + "trebek_18.npy\n", + "(1, 80, 580)\n", + "trebek_1550.npy\n", + "(1, 80, 565)\n", + "trebek_2159.npy\n", + "(1, 80, 675)\n", + "trebek_2405.npy\n", + "(1, 80, 510)\n", + "trebek_1001.npy\n", + "(1, 80, 373)\n", + "trebek_2195.npy\n", + "(1, 80, 626)\n", + "trebek_1725.npy\n", + "(1, 80, 484)\n", + "trebek_740.npy\n", + "(1, 80, 668)\n", + "trebek_2217.npy\n", + "(1, 80, 233)\n", + "trebek_1007.npy\n", + "(1, 80, 670)\n", + "trebek_163.npy\n", + "(1, 80, 468)\n", + "trebek_789.npy\n", + "(1, 80, 559)\n", + "trebek_2537.npy\n", + "(1, 80, 515)\n", + "trebek_1319.npy\n", + "(1, 80, 637)\n", + "trebek_2123.npy\n", + "(1, 80, 466)\n", + "trebek_170.npy\n", + "(1, 80, 972)\n", + "trebek_219.npy\n", + "(1, 80, 622)\n", + "trebek_2068.npy\n", + "(1, 80, 737)\n", + "trebek_2255.npy\n", + "(1, 80, 522)\n", + "trebek_454.npy\n", + "(1, 80, 729)\n", + "trebek_2095.npy\n", + "(1, 80, 644)\n", + "trebek_1948.npy\n", + "(1, 80, 659)\n", + "trebek_2177.npy\n", + "(1, 80, 471)\n", + "trebek_867.npy\n", + "(1, 80, 414)\n", + "trebek_2207.npy\n", + "(1, 80, 344)\n", + "trebek_51.npy\n", + "(1, 80, 493)\n", + "trebek_101.npy\n", + "(1, 80, 427)\n", + "trebek_1408.npy\n", + "(1, 80, 627)\n", + "trebek_2456.npy\n", + "(1, 80, 329)\n", + "trebek_810.npy\n", + "(1, 80, 851)\n", + "trebek_2357.npy\n", + "(1, 80, 336)\n", + "trebek_1231.npy\n", + "(1, 80, 600)\n", + "trebek_2381.npy\n", + "(1, 80, 623)\n", + "trebek_238.npy\n", + "(1, 80, 864)\n", + "trebek_271.npy\n", + "(1, 80, 822)\n", + "trebek_1071.npy\n", + "(1, 80, 849)\n", + "trebek_160.npy\n", + "(1, 80, 424)\n", + "trebek_906.npy\n", + "(1, 80, 481)\n", + "trebek_1777.npy\n", + "(1, 80, 463)\n", + "trebek_1664.npy\n", + "(1, 80, 650)\n", + "trebek_1581.npy\n", + "(1, 80, 525)\n", + "trebek_273.npy\n", + "(1, 80, 600)\n", + "trebek_2022.npy\n", + "(1, 80, 344)\n", + "trebek_1061.npy\n", + "(1, 80, 486)\n", + "trebek_1597.npy\n", + "(1, 80, 437)\n", + "trebek_126.npy\n", + "(1, 80, 539)\n", + "trebek_314.npy\n", + "(1, 80, 541)\n", + "trebek_1738.npy\n", + "(1, 80, 737)\n", + "trebek_121.npy\n", + "(1, 80, 480)\n", + "trebek_1775.npy\n", + "(1, 80, 615)\n", + "trebek_388.npy\n", + "(1, 80, 398)\n", + "trebek_622.npy\n", + "(1, 80, 748)\n", + "trebek_457.npy\n", + "(1, 80, 701)\n", + "trebek_1496.npy\n", + "(1, 80, 711)\n", + "trebek_2147.npy\n", + "(1, 80, 727)\n", + "trebek_1633.npy\n", + "(1, 80, 709)\n", + "trebek_1374.npy\n", + "(1, 80, 845)\n", + "trebek_787.npy\n", + "(1, 80, 603)\n", + "trebek_970.npy\n", + "(1, 80, 553)\n", + "trebek_200.npy\n", + "(1, 80, 735)\n", + "trebek_1665.npy\n", + "(1, 80, 608)\n", + "trebek_1058.npy\n", + "(1, 80, 615)\n", + "trebek_114.npy\n", + "(1, 80, 627)\n", + "trebek_1101.npy\n", + "(1, 80, 548)\n", + "trebek_1200.npy\n", + "(1, 80, 461)\n", + "trebek_1298.npy\n", + "(1, 80, 698)\n", + "trebek_50.npy\n", + "(1, 80, 548)\n", + "trebek_1182.npy\n", + "(1, 80, 553)\n", + "trebek_1215.npy\n", + "(1, 80, 450)\n", + "trebek_1641.npy\n", + "(1, 80, 419)\n", + "trebek_1601.npy\n", + "(1, 80, 194)\n", + "trebek_869.npy\n", + "(1, 80, 684)\n", + "trebek_1109.npy\n", + "(1, 80, 551)\n", + "trebek_356.npy\n", + "(1, 80, 445)\n", + "trebek_1136.npy\n", + "(1, 80, 314)\n", + "trebek_1297.npy\n", + "(1, 80, 533)\n", + "trebek_1660.npy\n", + "(1, 80, 595)\n", + "trebek_115.npy\n", + "(1, 80, 993)\n", + "trebek_1259.npy\n", + "(1, 80, 508)\n", + "trebek_2069.npy\n", + "(1, 80, 508)\n", + "trebek_2135.npy\n", + "(1, 80, 572)\n", + "trebek_1938.npy\n", + "(1, 80, 641)\n", + "trebek_1802.npy\n", + "(1, 80, 335)\n", + "trebek_602.npy\n", + "(1, 80, 520)\n", + "trebek_2544.npy\n", + "(1, 80, 280)\n", + "trebek_490.npy\n", + "(1, 80, 680)\n", + "trebek_2124.npy\n", + "(1, 80, 463)\n", + "trebek_1375.npy\n", + "(1, 80, 663)\n", + "trebek_1589.npy\n", + "(1, 80, 518)\n", + "trebek_2006.npy\n", + "(1, 80, 782)\n", + "trebek_1504.npy\n", + "(1, 80, 608)\n", + "trebek_882.npy\n", + "(1, 80, 654)\n", + "trebek_373.npy\n", + "(1, 80, 427)\n", + "trebek_1940.npy\n", + "(1, 80, 858)\n", + "trebek_718.npy\n", + "(1, 80, 763)\n", + "trebek_1020.npy\n", + "(1, 80, 548)\n", + "trebek_2196.npy\n", + "(1, 80, 448)\n", + "trebek_1893.npy\n", + "(1, 80, 674)\n", + "trebek_1683.npy\n", + "(1, 80, 690)\n", + "trebek_1209.npy\n", + "(1, 80, 610)\n", + "trebek_1337.npy\n", + "(1, 80, 507)\n", + "trebek_2038.npy\n", + "(1, 80, 662)\n", + "trebek_2160.npy\n", + "(1, 80, 572)\n", + "trebek_1549.npy\n", + "(1, 80, 597)\n", + "trebek_508.npy\n", + "(1, 80, 365)\n", + "trebek_420.npy\n", + "(1, 80, 339)\n", + "trebek_880.npy\n", + "(1, 80, 277)\n", + "trebek_2083.npy\n", + "(1, 80, 640)\n", + "trebek_1915.npy\n", + "(1, 80, 479)\n", + "trebek_1348.npy\n", + "(1, 80, 632)\n", + "trebek_1824.npy\n", + "(1, 80, 665)\n", + "trebek_1140.npy\n", + "(1, 80, 536)\n", + "trebek_1562.npy\n", + "(1, 80, 533)\n", + "trebek_2481.npy\n", + "(1, 80, 360)\n", + "trebek_1623.npy\n", + "(1, 80, 345)\n", + "trebek_531.npy\n", + "(1, 80, 792)\n", + "trebek_2020.npy\n", + "(1, 80, 667)\n", + "trebek_1690.npy\n", + "(1, 80, 791)\n", + "trebek_694.npy\n", + "(1, 80, 383)\n", + "trebek_113.npy\n", + "(1, 80, 745)\n", + "trebek_1734.npy\n", + "(1, 80, 613)\n", + "trebek_470.npy\n", + "(1, 80, 566)\n", + "trebek_1570.npy\n", + "(1, 80, 499)\n", + "trebek_2244.npy\n", + "(1, 80, 805)\n", + "trebek_1047.npy\n", + "(1, 80, 422)\n", + "trebek_2151.npy\n", + "(1, 80, 836)\n", + "trebek_1307.npy\n", + "(1, 80, 598)\n", + "trebek_2108.npy\n", + "(1, 80, 621)\n", + "trebek_750.npy\n", + "(1, 80, 609)\n", + "trebek_845.npy\n", + "(1, 80, 721)\n", + "trebek_60.npy\n", + "(1, 80, 411)\n", + "trebek_785.npy\n", + "(1, 80, 622)\n", + "trebek_1621.npy\n", + "(1, 80, 398)\n", + "trebek_2010.npy\n", + "(1, 80, 815)\n", + "trebek_282.npy\n", + "(1, 80, 765)\n", + "trebek_1739.npy\n", + "(1, 80, 701)\n", + "trebek_921.npy\n", + "(1, 80, 544)\n", + "trebek_2328.npy\n", + "(1, 80, 716)\n", + "trebek_782.npy\n", + "(1, 80, 541)\n", + "trebek_621.npy\n", + "(1, 80, 685)\n", + "trebek_981.npy\n", + "(1, 80, 440)\n", + "trebek_638.npy\n", + "(1, 80, 659)\n", + "trebek_1787.npy\n", + "(1, 80, 409)\n", + "trebek_1676.npy\n", + "(1, 80, 354)\n", + "trebek_84.npy\n", + "(1, 80, 385)\n", + "trebek_2082.npy\n", + "(1, 80, 603)\n", + "trebek_2348.npy\n", + "(1, 80, 536)\n", + "trebek_760.npy\n", + "(1, 80, 285)\n", + "trebek_1568.npy\n", + "(1, 80, 225)\n", + "trebek_235.npy\n", + "(1, 80, 1029)\n", + "trebek_395.npy\n", + "(1, 80, 657)\n", + "trebek_1130.npy\n", + "(1, 80, 827)\n", + "trebek_1692.npy\n", + "(1, 80, 419)\n", + "trebek_2524.npy\n", + "(1, 80, 404)\n", + "trebek_672.npy\n", + "(1, 80, 441)\n", + "trebek_619.npy\n", + "(1, 80, 605)\n", + "trebek_661.npy\n", + "(1, 80, 454)\n", + "trebek_901.npy\n", + "(1, 80, 645)\n", + "trebek_2542.npy\n", + "(1, 80, 365)\n", + "trebek_1927.npy\n", + "(1, 80, 717)\n", + "trebek_2059.npy\n", + "(1, 80, 789)\n", + "trebek_937.npy\n", + "(1, 80, 750)\n", + "trebek_1170.npy\n", + "(1, 80, 649)\n", + "trebek_1360.npy\n", + "(1, 80, 579)\n", + "trebek_1034.npy\n", + "(1, 80, 598)\n", + "trebek_2271.npy\n", + "(1, 80, 641)\n", + "trebek_1067.npy\n", + "(1, 80, 350)\n", + "trebek_564.npy\n", + "(1, 80, 817)\n", + "trebek_788.npy\n", + "(1, 80, 358)\n", + "trebek_588.npy\n", + "(1, 80, 685)\n", + "trebek_1108.npy\n", + "(1, 80, 639)\n", + "trebek_1349.npy\n", + "(1, 80, 843)\n", + "trebek_1951.npy\n", + "(1, 80, 398)\n", + "trebek_19.npy\n", + "(1, 80, 685)\n", + "trebek_1742.npy\n", + "(1, 80, 758)\n", + "trebek_2101.npy\n", + "(1, 80, 818)\n", + "trebek_1494.npy\n", + "(1, 80, 629)\n", + "trebek_1060.npy\n", + "(1, 80, 712)\n", + "trebek_1643.npy\n", + "(1, 80, 300)\n", + "trebek_738.npy\n", + "(1, 80, 590)\n", + "trebek_1651.npy\n", + "(1, 80, 497)\n", + "trebek_700.npy\n", + "(1, 80, 864)\n", + "trebek_1351.npy\n", + "(1, 80, 526)\n", + "trebek_520.npy\n", + "(1, 80, 590)\n", + "trebek_1532.npy\n", + "(1, 80, 471)\n", + "trebek_429.npy\n", + "(1, 80, 721)\n", + "trebek_517.npy\n", + "(1, 80, 703)\n", + "trebek_1313.npy\n", + "(1, 80, 613)\n", + "trebek_1492.npy\n", + "(1, 80, 579)\n", + "trebek_2002.npy\n", + "(1, 80, 443)\n", + "trebek_1619.npy\n", + "(1, 80, 205)\n", + "trebek_1353.npy\n", + "(1, 80, 484)\n", + "trebek_1487.npy\n", + "(1, 80, 518)\n", + "trebek_597.npy\n", + "(1, 80, 622)\n", + "trebek_2057.npy\n", + "(1, 80, 382)\n", + "trebek_737.npy\n", + "(1, 80, 758)\n", + "trebek_919.npy\n", + "(1, 80, 480)\n", + "trebek_631.npy\n", + "(1, 80, 657)\n", + "trebek_1757.npy\n", + "(1, 80, 491)\n", + "trebek_21.npy\n", + "(1, 80, 833)\n", + "trebek_1364.npy\n", + "(1, 80, 507)\n", + "trebek_2143.npy\n", + "(1, 80, 662)\n", + "trebek_2367.npy\n", + "(1, 80, 528)\n", + "trebek_1404.npy\n", + "(1, 80, 808)\n", + "trebek_739.npy\n", + "(1, 80, 559)\n", + "trebek_692.npy\n", + "(1, 80, 598)\n", + "trebek_817.npy\n", + "(1, 80, 463)\n", + "trebek_197.npy\n", + "(1, 80, 525)\n", + "trebek_1186.npy\n", + "(1, 80, 500)\n", + "trebek_1508.npy\n", + "(1, 80, 654)\n", + "trebek_556.npy\n", + "(1, 80, 565)\n", + "trebek_2311.npy\n", + "(1, 80, 796)\n", + "trebek_2041.npy\n", + "(1, 80, 313)\n", + "trebek_1907.npy\n", + "(1, 80, 1057)\n", + "trebek_1631.npy\n", + "(1, 80, 505)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "trebek_2417.npy\n", + "(1, 80, 603)\n", + "trebek_827.npy\n", + "(1, 80, 575)\n", + "trebek_1521.npy\n", + "(1, 80, 665)\n", + "trebek_70.npy\n", + "(1, 80, 727)\n", + "trebek_383.npy\n", + "(1, 80, 791)\n", + "trebek_1210.npy\n", + "(1, 80, 507)\n", + "trebek_33.npy\n", + "(1, 80, 846)\n", + "trebek_677.npy\n", + "(1, 80, 719)\n", + "trebek_1473.npy\n", + "(1, 80, 764)\n", + "trebek_2407.npy\n", + "(1, 80, 306)\n", + "trebek_406.npy\n", + "(1, 80, 305)\n", + "trebek_763.npy\n", + "(1, 80, 293)\n", + "trebek_1999.npy\n", + "(1, 80, 587)\n", + "trebek_1669.npy\n", + "(1, 80, 442)\n", + "trebek_954.npy\n", + "(1, 80, 668)\n", + "trebek_1780.npy\n", + "(1, 80, 598)\n", + "trebek_20.npy\n", + "(1, 80, 899)\n", + "trebek_713.npy\n", + "(1, 80, 654)\n", + "trebek_2438.npy\n", + "(1, 80, 783)\n", + "trebek_308.npy\n", + "(1, 80, 547)\n", + "trebek_465.npy\n", + "(1, 80, 691)\n", + "trebek_2278.npy\n", + "(1, 80, 388)\n", + "trebek_1663.npy\n", + "(1, 80, 752)\n", + "trebek_1088.npy\n", + "(1, 80, 742)\n", + "trebek_139.npy\n", + "(1, 80, 685)\n", + "trebek_1834.npy\n", + "(1, 80, 467)\n", + "trebek_1857.npy\n", + "(1, 80, 634)\n", + "trebek_679.npy\n", + "(1, 80, 367)\n", + "trebek_2154.npy\n", + "(1, 80, 751)\n", + "trebek_401.npy\n", + "(1, 80, 587)\n", + "trebek_161.npy\n", + "(1, 80, 758)\n", + "trebek_2471.npy\n", + "(1, 80, 541)\n", + "trebek_2204.npy\n", + "(1, 80, 684)\n", + "trebek_127.npy\n", + "(1, 80, 261)\n", + "trebek_1869.npy\n", + "(1, 80, 628)\n", + "trebek_1128.npy\n", + "(1, 80, 639)\n", + "trebek_476.npy\n", + "(1, 80, 595)\n", + "trebek_666.npy\n", + "(1, 80, 458)\n", + "trebek_1343.npy\n", + "(1, 80, 783)\n", + "trebek_1896.npy\n", + "(1, 80, 507)\n", + "trebek_1338.npy\n", + "(1, 80, 843)\n", + "trebek_1394.npy\n", + "(1, 80, 503)\n", + "trebek_2353.npy\n", + "(1, 80, 747)\n", + "trebek_1706.npy\n", + "(1, 80, 468)\n", + "trebek_1556.npy\n", + "(1, 80, 711)\n", + "trebek_1615.npy\n", + "(1, 80, 858)\n", + "trebek_350.npy\n", + "(1, 80, 460)\n", + "trebek_2226.npy\n", + "(1, 80, 373)\n", + "trebek_326.npy\n", + "(1, 80, 861)\n", + "trebek_1908.npy\n", + "(1, 80, 658)\n", + "trebek_2192.npy\n", + "(1, 80, 722)\n", + "trebek_1256.npy\n", + "(1, 80, 251)\n", + "trebek_2528.npy\n", + "(1, 80, 398)\n", + "trebek_2567.npy\n", + "(1, 80, 331)\n", + "trebek_265.npy\n", + "(1, 80, 499)\n", + "trebek_2501.npy\n", + "(1, 80, 419)\n", + "trebek_446.npy\n", + "(1, 80, 623)\n", + "trebek_1454.npy\n", + "(1, 80, 683)\n", + "trebek_250.npy\n", + "(1, 80, 843)\n", + "trebek_1800.npy\n", + "(1, 80, 533)\n", + "trebek_1107.npy\n", + "(1, 80, 622)\n", + "trebek_1878.npy\n", + "(1, 80, 484)\n", + "trebek_881.npy\n", + "(1, 80, 463)\n", + "trebek_2240.npy\n", + "(1, 80, 256)\n", + "trebek_705.npy\n", + "(1, 80, 640)\n", + "trebek_1985.npy\n", + "(1, 80, 667)\n", + "trebek_1013.npy\n", + "(1, 80, 745)\n", + "trebek_1719.npy\n", + "(1, 80, 368)\n", + "trebek_1054.npy\n", + "(1, 80, 735)\n", + "trebek_1501.npy\n", + "(1, 80, 683)\n", + "trebek_2.npy\n", + "(1, 80, 913)\n", + "trebek_1271.npy\n", + "(1, 80, 539)\n", + "trebek_962.npy\n", + "(1, 80, 570)\n", + "trebek_425.npy\n", + "(1, 80, 450)\n", + "trebek_1216.npy\n", + "(1, 80, 668)\n", + "trebek_23.npy\n", + "(1, 80, 517)\n", + "trebek_29.npy\n", + "(1, 80, 634)\n", + "trebek_898.npy\n", + "(1, 80, 320)\n", + "trebek_2475.npy\n", + "(1, 80, 508)\n", + "trebek_569.npy\n", + "(1, 80, 510)\n", + "trebek_707.npy\n", + "(1, 80, 975)\n", + "trebek_316.npy\n", + "(1, 80, 897)\n", + "trebek_1456.npy\n", + "(1, 80, 724)\n", + "trebek_2461.npy\n", + "(1, 80, 236)\n", + "trebek_132.npy\n", + "(1, 80, 838)\n", + "trebek_612.npy\n", + "(1, 80, 747)\n", + "trebek_1258.npy\n", + "(1, 80, 698)\n", + "trebek_1983.npy\n", + "(1, 80, 703)\n", + "trebek_1089.npy\n", + "(1, 80, 784)\n", + "trebek_1154.npy\n", + "(1, 80, 547)\n", + "trebek_57.npy\n", + "(1, 80, 698)\n", + "trebek_1393.npy\n", + "(1, 80, 406)\n", + "trebek_2181.npy\n", + "(1, 80, 535)\n", + "trebek_230.npy\n", + "(1, 80, 437)\n", + "trebek_167.npy\n", + "(1, 80, 670)\n", + "trebek_1039.npy\n", + "(1, 80, 357)\n", + "trebek_1245.npy\n", + "(1, 80, 900)\n", + "trebek_660.npy\n", + "(1, 80, 688)\n", + "trebek_840.npy\n", + "(1, 80, 565)\n", + "trebek_1931.npy\n", + "(1, 80, 466)\n", + "trebek_2029.npy\n", + "(1, 80, 619)\n", + "trebek_511.npy\n", + "(1, 80, 507)\n", + "trebek_608.npy\n", + "(1, 80, 688)\n", + "trebek_1529.npy\n", + "(1, 80, 420)\n", + "trebek_354.npy\n", + "(1, 80, 683)\n", + "trebek_928.npy\n", + "(1, 80, 404)\n", + "trebek_99.npy\n", + "(1, 80, 603)\n", + "trebek_761.npy\n", + "(1, 80, 505)\n", + "trebek_2342.npy\n", + "(1, 80, 605)\n", + "trebek_1252.npy\n", + "(1, 80, 631)\n", + "trebek_1029.npy\n", + "(1, 80, 367)\n", + "trebek_2185.npy\n", + "(1, 80, 277)\n", + "trebek_958.npy\n", + "(1, 80, 556)\n", + "trebek_2166.npy\n", + "(1, 80, 450)\n", + "trebek_392.npy\n", + "(1, 80, 786)\n", + "trebek_492.npy\n", + "(1, 80, 702)\n", + "trebek_2283.npy\n", + "(1, 80, 533)\n", + "trebek_1276.npy\n", + "(1, 80, 380)\n", + "trebek_1722.npy\n", + "(1, 80, 631)\n", + "trebek_1797.npy\n", + "(1, 80, 367)\n", + "trebek_276.npy\n", + "(1, 80, 608)\n", + "trebek_2389.npy\n", + "(1, 80, 388)\n", + "trebek_529.npy\n", + "(1, 80, 600)\n", + "trebek_1588.npy\n", + "(1, 80, 324)\n", + "trebek_1365.npy\n", + "(1, 80, 680)\n", + "trebek_1579.npy\n", + "(1, 80, 688)\n", + "trebek_1877.npy\n", + "(1, 80, 587)\n", + "trebek_2305.npy\n", + "(1, 80, 587)\n", + "trebek_1242.npy\n", + "(1, 80, 786)\n", + "trebek_2320.npy\n", + "(1, 80, 751)\n", + "trebek_501.npy\n", + "(1, 80, 654)\n", + "trebek_1248.npy\n", + "(1, 80, 608)\n", + "trebek_2141.npy\n", + "(1, 80, 606)\n", + "trebek_2376.npy\n", + "(1, 80, 600)\n", + "trebek_2218.npy\n", + "(1, 80, 627)\n", + "trebek_728.npy\n", + "(1, 80, 644)\n", + "trebek_313.npy\n", + "(1, 80, 876)\n", + "trebek_842.npy\n", + "(1, 80, 365)\n", + "trebek_1541.npy\n", + "(1, 80, 663)\n", + "trebek_752.npy\n", + "(1, 80, 533)\n", + "trebek_764.npy\n", + "(1, 80, 669)\n", + "trebek_69.npy\n", + "(1, 80, 504)\n", + "trebek_2077.npy\n", + "(1, 80, 466)\n", + "trebek_1045.npy\n", + "(1, 80, 326)\n", + "trebek_258.npy\n", + "(1, 80, 851)\n", + "trebek_389.npy\n", + "(1, 80, 566)\n", + "trebek_644.npy\n", + "(1, 80, 892)\n", + "trebek_2178.npy\n", + "(1, 80, 371)\n", + "trebek_386.npy\n", + "(1, 80, 574)\n", + "trebek_807.npy\n", + "(1, 80, 510)\n", + "trebek_499.npy\n", + "(1, 80, 541)\n", + "trebek_839.npy\n", + "(1, 80, 497)\n", + "trebek_1354.npy\n", + "(1, 80, 603)\n", + "trebek_1829.npy\n", + "(1, 80, 463)\n", + "trebek_1700.npy\n", + "(1, 80, 590)\n", + "trebek_2296.npy\n", + "(1, 80, 355)\n", + "trebek_1627.npy\n", + "(1, 80, 867)\n", + "trebek_2242.npy\n", + "(1, 80, 391)\n", + "trebek_883.npy\n", + "(1, 80, 696)\n", + "trebek_2216.npy\n", + "(1, 80, 259)\n", + "trebek_225.npy\n", + "(1, 80, 892)\n", + "trebek_2100.npy\n", + "(1, 80, 233)\n", + "trebek_1228.npy\n", + "(1, 80, 579)\n", + "trebek_2446.npy\n", + "(1, 80, 515)\n", + "trebek_1531.npy\n", + "(1, 80, 721)\n", + "trebek_1606.npy\n", + "(1, 80, 396)\n", + "trebek_445.npy\n", + "(1, 80, 727)\n", + "trebek_571.npy\n", + "(1, 80, 220)\n", + "trebek_913.npy\n", + "(1, 80, 604)\n", + "trebek_1470.npy\n", + "(1, 80, 624)\n", + "trebek_2187.npy\n", + "(1, 80, 672)\n", + "trebek_2362.npy\n", + "(1, 80, 399)\n", + "trebek_272.npy\n", + "(1, 80, 667)\n", + "trebek_1889.npy\n", + "(1, 80, 745)\n", + "trebek_533.npy\n", + "(1, 80, 667)\n", + "trebek_649.npy\n", + "(1, 80, 621)\n", + "trebek_1749.npy\n", + "(1, 80, 652)\n", + "trebek_62.npy\n", + "(1, 80, 734)\n", + "trebek_2316.npy\n", + "(1, 80, 727)\n", + "trebek_1097.npy\n", + "(1, 80, 509)\n", + "trebek_210.npy\n", + "(1, 80, 557)\n", + "trebek_950.npy\n", + "(1, 80, 318)\n", + "trebek_539.npy\n", + "(1, 80, 742)\n", + "trebek_960.npy\n", + "(1, 80, 388)\n", + "trebek_2420.npy\n", + "(1, 80, 742)\n", + "trebek_1732.npy\n", + "(1, 80, 603)\n", + "trebek_415.npy\n", + "(1, 80, 624)\n", + "trebek_1515.npy\n", + "(1, 80, 529)\n", + "trebek_509.npy\n", + "(1, 80, 864)\n", + "trebek_2042.npy\n", + "(1, 80, 541)\n", + "trebek_2175.npy\n", + "(1, 80, 479)\n", + "trebek_1250.npy\n", + "(1, 80, 422)\n", + "trebek_2172.npy\n", + "(1, 80, 709)\n", + "trebek_512.npy\n", + "(1, 80, 584)\n", + "trebek_89.npy\n", + "(1, 80, 714)\n", + "trebek_431.npy\n", + "(1, 80, 430)\n", + "trebek_1751.npy\n", + "(1, 80, 559)\n", + "trebek_1163.npy\n", + "(1, 80, 448)\n", + "trebek_838.npy\n", + "(1, 80, 773)\n", + "trebek_402.npy\n", + "(1, 80, 636)\n", + "trebek_2107.npy\n", + "(1, 80, 587)\n", + "trebek_1331.npy\n", + "(1, 80, 665)\n", + "trebek_2249.npy\n", + "(1, 80, 871)\n", + "trebek_187.npy\n", + "(1, 80, 556)\n", + "trebek_850.npy\n", + "(1, 80, 556)\n", + "trebek_540.npy\n", + "(1, 80, 526)\n", + "trebek_466.npy\n", + "(1, 80, 675)\n", + "trebek_1048.npy\n", + "(1, 80, 334)\n", + "trebek_2034.npy\n", + "(1, 80, 1096)\n", + "trebek_1866.npy\n", + "(1, 80, 701)\n", + "trebek_1698.npy\n", + "(1, 80, 443)\n", + "trebek_41.npy\n", + "(1, 80, 598)\n", + "trebek_951.npy\n", + "(1, 80, 632)\n", + "trebek_2098.npy\n", + "(1, 80, 587)\n", + "trebek_1561.npy\n", + "(1, 80, 492)\n", + "trebek_2556.npy\n", + "(1, 80, 366)\n", + "trebek_892.npy\n", + "(1, 80, 572)\n", + "trebek_1306.npy\n", + "(1, 80, 388)\n", + "trebek_1804.npy\n", + "(1, 80, 768)\n", + "trebek_141.npy\n", + "(1, 80, 522)\n", + "trebek_2263.npy\n", + "(1, 80, 699)\n", + "trebek_93.npy\n", + "(1, 80, 634)\n", + "trebek_1705.npy\n", + "(1, 80, 746)\n", + "trebek_1765.npy\n", + "(1, 80, 618)\n", + "trebek_936.npy\n", + "(1, 80, 732)\n", + "trebek_527.npy\n", + "(1, 80, 528)\n", + "trebek_665.npy\n", + "(1, 80, 777)\n", + "trebek_1923.npy\n", + "(1, 80, 626)\n", + "trebek_130.npy\n", + "(1, 80, 597)\n", + "trebek_2354.npy\n", + "(1, 80, 592)\n", + "trebek_1978.npy\n", + "(1, 80, 653)\n", + "trebek_2018.npy\n", + "(1, 80, 665)\n", + "trebek_483.npy\n", + "(1, 80, 504)\n", + "trebek_1835.npy\n", + "(1, 80, 328)\n", + "trebek_63.npy\n", + "(1, 80, 546)\n", + "trebek_2514.npy\n", + "(1, 80, 318)\n", + "trebek_651.npy\n", + "(1, 80, 702)\n", + "trebek_1905.npy\n", + "(1, 80, 725)\n", + "trebek_77.npy\n", + "(1, 80, 747)\n", + "trebek_1310.npy\n", + "(1, 80, 466)\n", + "trebek_2164.npy\n", + "(1, 80, 727)\n", + "trebek_1482.npy\n", + "(1, 80, 212)\n", + "trebek_1010.npy\n", + "(1, 80, 548)\n", + "trebek_978.npy\n", + "(1, 80, 523)\n", + "trebek_207.npy\n", + "(1, 80, 820)\n", + "trebek_574.npy\n", + "(1, 80, 525)\n", + "trebek_1056.npy\n", + "(1, 80, 768)\n", + "trebek_105.npy\n", + "(1, 80, 649)\n", + "trebek_204.npy\n", + "(1, 80, 810)\n", + "trebek_593.npy\n", + "(1, 80, 735)\n", + "trebek_609.npy\n", + "(1, 80, 797)\n", + "trebek_1287.npy\n", + "(1, 80, 641)\n", + "trebek_1972.npy\n", + "(1, 80, 628)\n", + "trebek_595.npy\n", + "(1, 80, 587)\n", + "trebek_1783.npy\n", + "(1, 80, 592)\n", + "trebek_1947.npy\n", + "(1, 80, 623)\n", + "trebek_2157.npy\n", + "(1, 80, 655)\n", + "trebek_2269.npy\n", + "(1, 80, 538)\n", + "trebek_1686.npy\n", + "(1, 80, 721)\n", + "trebek_1471.npy\n", + "(1, 80, 615)\n", + "trebek_808.npy\n", + "(1, 80, 542)\n", + "trebek_2355.npy\n", + "(1, 80, 587)\n", + "trebek_1856.npy\n", + "(1, 80, 746)\n", + "trebek_2515.npy\n", + "(1, 80, 342)\n", + "trebek_98.npy\n", + "(1, 80, 696)\n", + "trebek_2227.npy\n", + "(1, 80, 541)\n", + "trebek_1852.npy\n", + "(1, 80, 572)\n", + "trebek_1988.npy\n", + "(1, 80, 445)\n", + "trebek_832.npy\n", + "(1, 80, 502)\n", + "trebek_1407.npy\n", + "(1, 80, 479)\n", + "trebek_963.npy\n", + "(1, 80, 486)\n", + "trebek_2021.npy\n", + "(1, 80, 409)\n", + "trebek_1976.npy\n", + "(1, 80, 794)\n", + "trebek_72.npy\n", + "(1, 80, 406)\n", + "trebek_302.npy\n", + "(1, 80, 529)\n", + "trebek_1465.npy\n", + "(1, 80, 449)\n", + "trebek_61.npy\n", + "(1, 80, 862)\n", + "trebek_809.npy\n", + "(1, 80, 715)\n", + "trebek_977.npy\n", + "(1, 80, 665)\n", + "trebek_606.npy\n", + "(1, 80, 546)\n", + "trebek_116.npy\n", + "(1, 80, 634)\n", + "trebek_1498.npy\n", + "(1, 80, 303)\n", + "trebek_1794.npy\n", + "(1, 80, 551)\n", + "trebek_1540.npy\n", + "(1, 80, 530)\n", + "trebek_2493.npy\n", + "(1, 80, 380)\n", + "trebek_1102.npy\n", + "(1, 80, 530)\n", + "trebek_2275.npy\n", + "(1, 80, 685)\n", + "trebek_1388.npy\n", + "(1, 80, 556)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "trebek_150.npy\n", + "(1, 80, 711)\n", + "trebek_488.npy\n", + "(1, 80, 495)\n", + "trebek_1536.npy\n", + "(1, 80, 773)\n", + "trebek_1347.npy\n", + "(1, 80, 724)\n", + "trebek_1062.npy\n", + "(1, 80, 605)\n", + "trebek_180.npy\n", + "(1, 80, 479)\n", + "trebek_379.npy\n", + "(1, 80, 584)\n", + "trebek_1535.npy\n", + "(1, 80, 515)\n", + "trebek_1279.npy\n", + "(1, 80, 722)\n", + "trebek_2449.npy\n", + "(1, 80, 525)\n", + "trebek_1784.npy\n", + "(1, 80, 750)\n", + "trebek_967.npy\n", + "(1, 80, 657)\n", + "trebek_1901.npy\n", + "(1, 80, 699)\n", + "trebek_1178.npy\n", + "(1, 80, 502)\n", + "trebek_659.npy\n", + "(1, 80, 659)\n", + "trebek_2150.npy\n", + "(1, 80, 729)\n", + "trebek_2273.npy\n", + "(1, 80, 779)\n", + "trebek_1527.npy\n", + "(1, 80, 388)\n", + "trebek_1227.npy\n", + "(1, 80, 603)\n", + "trebek_1442.npy\n", + "(1, 80, 342)\n", + "trebek_1552.npy\n", + "(1, 80, 701)\n", + "trebek_2467.npy\n", + "(1, 80, 316)\n", + "trebek_2105.npy\n", + "(1, 80, 637)\n", + "trebek_404.npy\n", + "(1, 80, 616)\n", + "trebek_97.npy\n", + "(1, 80, 706)\n", + "trebek_1788.npy\n", + "(1, 80, 525)\n", + "trebek_283.npy\n", + "(1, 80, 517)\n", + "trebek_2301.npy\n", + "(1, 80, 349)\n", + "trebek_2130.npy\n", + "(1, 80, 730)\n", + "trebek_749.npy\n", + "(1, 80, 649)\n", + "trebek_1431.npy\n", + "(1, 80, 814)\n", + "trebek_944.npy\n", + "(1, 80, 680)\n", + "trebek_1224.npy\n", + "(1, 80, 597)\n", + "trebek_1964.npy\n", + "(1, 80, 432)\n", + "trebek_1510.npy\n", + "(1, 80, 538)\n", + "trebek_2363.npy\n", + "(1, 80, 497)\n", + "trebek_1747.npy\n", + "(1, 80, 482)\n", + "trebek_1710.npy\n", + "(1, 80, 491)\n", + "trebek_1891.npy\n", + "(1, 80, 721)\n", + "trebek_664.npy\n", + "(1, 80, 295)\n", + "trebek_1272.npy\n", + "(1, 80, 517)\n", + "trebek_2173.npy\n", + "(1, 80, 547)\n", + "trebek_1613.npy\n", + "(1, 80, 737)\n", + "trebek_280.npy\n", + "(1, 80, 491)\n", + "trebek_281.npy\n", + "(1, 80, 698)\n", + "trebek_1645.npy\n", + "(1, 80, 220)\n", + "trebek_119.npy\n", + "(1, 80, 515)\n", + "trebek_1426.npy\n", + "(1, 80, 407)\n", + "trebek_1400.npy\n", + "(1, 80, 773)\n", + "trebek_290.npy\n", + "(1, 80, 507)\n", + "trebek_1012.npy\n", + "(1, 80, 624)\n", + "trebek_929.npy\n", + "(1, 80, 321)\n", + "trebek_1720.npy\n", + "(1, 80, 610)\n", + "trebek_1303.npy\n", + "(1, 80, 733)\n", + "trebek_474.npy\n", + "(1, 80, 707)\n", + "trebek_472.npy\n", + "(1, 80, 807)\n", + "trebek_2233.npy\n", + "(1, 80, 636)\n", + "trebek_1124.npy\n", + "(1, 80, 768)\n", + "trebek_279.npy\n", + "(1, 80, 741)\n", + "trebek_241.npy\n", + "(1, 80, 760)\n", + "trebek_2309.npy\n", + "(1, 80, 445)\n", + "trebek_32.npy\n", + "(1, 80, 362)\n", + "trebek_1512.npy\n", + "(1, 80, 665)\n", + "trebek_1396.npy\n", + "(1, 80, 569)\n", + "trebek_1966.npy\n", + "(1, 80, 631)\n", + "trebek_942.npy\n", + "(1, 80, 471)\n", + "trebek_169.npy\n", + "(1, 80, 650)\n", + "trebek_2325.npy\n", + "(1, 80, 455)\n", + "trebek_1381.npy\n", + "(1, 80, 633)\n", + "trebek_1959.npy\n", + "(1, 80, 554)\n", + "trebek_1929.npy\n", + "(1, 80, 711)\n", + "trebek_1369.npy\n", + "(1, 80, 619)\n", + "trebek_2074.npy\n", + "(1, 80, 954)\n", + "trebek_1693.npy\n", + "(1, 80, 365)\n", + "trebek_413.npy\n", + "(1, 80, 450)\n", + "trebek_1600.npy\n", + "(1, 80, 280)\n", + "trebek_157.npy\n", + "(1, 80, 794)\n", + "trebek_1818.npy\n", + "(1, 80, 727)\n", + "trebek_248.npy\n", + "(1, 80, 492)\n", + "trebek_1165.npy\n", + "(1, 80, 404)\n", + "trebek_1727.npy\n", + "(1, 80, 807)\n", + "trebek_2457.npy\n", + "(1, 80, 210)\n", + "trebek_284.npy\n", + "(1, 80, 495)\n", + "trebek_2460.npy\n", + "(1, 80, 347)\n", + "trebek_831.npy\n", + "(1, 80, 536)\n", + "trebek_806.npy\n", + "(1, 80, 518)\n", + "trebek_1074.npy\n", + "(1, 80, 386)\n", + "trebek_2312.npy\n", + "(1, 80, 410)\n", + "trebek_2211.npy\n", + "(1, 80, 657)\n", + "trebek_172.npy\n", + "(1, 80, 640)\n", + "trebek_1401.npy\n", + "(1, 80, 598)\n", + "trebek_765.npy\n", + "(1, 80, 531)\n", + "trebek_1225.npy\n", + "(1, 80, 510)\n", + "trebek_2126.npy\n", + "(1, 80, 487)\n", + "trebek_1941.npy\n", + "(1, 80, 559)\n", + "trebek_2462.npy\n", + "(1, 80, 218)\n", + "trebek_2037.npy\n", + "(1, 80, 437)\n", + "trebek_2479.npy\n", + "(1, 80, 279)\n", + "trebek_2313.npy\n", + "(1, 80, 613)\n", + "trebek_2397.npy\n", + "(1, 80, 567)\n", + "trebek_636.npy\n", + "(1, 80, 890)\n", + "trebek_857.npy\n", + "(1, 80, 737)\n", + "trebek_676.npy\n", + "(1, 80, 534)\n", + "trebek_1713.npy\n", + "(1, 80, 479)\n", + "trebek_1397.npy\n", + "(1, 80, 835)\n", + "trebek_1789.npy\n", + "(1, 80, 652)\n", + "trebek_17.npy\n", + "(1, 80, 641)\n", + "trebek_505.npy\n", + "(1, 80, 530)\n", + "trebek_1995.npy\n", + "(1, 80, 427)\n", + "trebek_1172.npy\n", + "(1, 80, 332)\n", + "trebek_1555.npy\n", + "(1, 80, 670)\n", + "trebek_598.npy\n", + "(1, 80, 608)\n", + "trebek_814.npy\n", + "(1, 80, 610)\n", + "trebek_759.npy\n", + "(1, 80, 535)\n", + "trebek_312.npy\n", + "(1, 80, 862)\n", + "trebek_1112.npy\n", + "(1, 80, 406)\n", + "trebek_1910.npy\n", + "(1, 80, 672)\n", + "trebek_948.npy\n", + "(1, 80, 349)\n", + "trebek_1430.npy\n", + "(1, 80, 552)\n", + "trebek_1315.npy\n", + "(1, 80, 614)\n", + "trebek_2303.npy\n", + "(1, 80, 587)\n", + "trebek_1077.npy\n", + "(1, 80, 566)\n", + "trebek_1724.npy\n", + "(1, 80, 466)\n", + "trebek_2299.npy\n", + "(1, 80, 391)\n", + "trebek_641.npy\n", + "(1, 80, 530)\n", + "trebek_2485.npy\n", + "(1, 80, 306)\n", + "trebek_816.npy\n", + "(1, 80, 647)\n", + "trebek_156.npy\n", + "(1, 80, 504)\n", + "trebek_215.npy\n", + "(1, 80, 662)\n", + "trebek_393.npy\n", + "(1, 80, 696)\n", + "trebek_745.npy\n", + "(1, 80, 659)\n", + "trebek_1445.npy\n", + "(1, 80, 595)\n", + "trebek_1902.npy\n", + "(1, 80, 817)\n", + "trebek_1993.npy\n", + "(1, 80, 626)\n", + "trebek_398.npy\n", + "(1, 80, 541)\n", + "trebek_1718.npy\n", + "(1, 80, 530)\n", + "trebek_1370.npy\n", + "(1, 80, 799)\n", + "trebek_989.npy\n", + "(1, 80, 473)\n", + "trebek_2321.npy\n", + "(1, 80, 595)\n", + "trebek_1395.npy\n", + "(1, 80, 419)\n", + "trebek_1037.npy\n", + "(1, 80, 634)\n", + "trebek_442.npy\n", + "(1, 80, 274)\n", + "trebek_1503.npy\n", + "(1, 80, 853)\n", + "trebek_1460.npy\n", + "(1, 80, 747)\n", + "trebek_714.npy\n", + "(1, 80, 724)\n", + "trebek_2252.npy\n", + "(1, 80, 468)\n", + "trebek_1821.npy\n", + "(1, 80, 517)\n", + "trebek_2513.npy\n", + "(1, 80, 370)\n", + "trebek_305.npy\n", + "(1, 80, 712)\n", + "trebek_1027.npy\n", + "(1, 80, 460)\n", + "trebek_179.npy\n", + "(1, 80, 795)\n", + "trebek_888.npy\n", + "(1, 80, 619)\n", + "trebek_1129.npy\n", + "(1, 80, 740)\n", + "trebek_1711.npy\n", + "(1, 80, 318)\n", + "trebek_696.npy\n", + "(1, 80, 756)\n", + "trebek_1565.npy\n", + "(1, 80, 691)\n", + "trebek_264.npy\n", + "(1, 80, 574)\n", + "trebek_2403.npy\n", + "(1, 80, 510)\n", + "trebek_1413.npy\n", + "(1, 80, 448)\n", + "trebek_1876.npy\n", + "(1, 80, 205)\n", + "trebek_171.npy\n", + "(1, 80, 484)\n", + "trebek_1918.npy\n", + "(1, 80, 561)\n", + "trebek_2194.npy\n", + "(1, 80, 479)\n", + "trebek_1361.npy\n", + "(1, 80, 230)\n", + "trebek_381.npy\n", + "(1, 80, 670)\n", + "trebek_2215.npy\n", + "(1, 80, 321)\n", + "trebek_2198.npy\n", + "(1, 80, 608)\n", + "trebek_1311.npy\n", + "(1, 80, 212)\n", + "trebek_59.npy\n", + "(1, 80, 910)\n", + "trebek_1860.npy\n", + "(1, 80, 541)\n", + "trebek_1885.npy\n", + "(1, 80, 647)\n", + "trebek_1153.npy\n", + "(1, 80, 608)\n", + "trebek_2125.npy\n", + "(1, 80, 776)\n", + "trebek_2379.npy\n", + "(1, 80, 598)\n", + "trebek_177.npy\n", + "(1, 80, 641)\n", + "trebek_444.npy\n", + "(1, 80, 582)\n", + "trebek_1768.npy\n", + "(1, 80, 747)\n", + "trebek_226.npy\n", + "(1, 80, 715)\n", + "trebek_1858.npy\n", + "(1, 80, 639)\n", + "trebek_297.npy\n", + "(1, 80, 626)\n", + "trebek_1191.npy\n", + "(1, 80, 871)\n", + "trebek_1005.npy\n", + "(1, 80, 417)\n", + "trebek_2213.npy\n", + "(1, 80, 657)\n", + "trebek_2399.npy\n", + "(1, 80, 499)\n", + "trebek_1770.npy\n", + "(1, 80, 479)\n", + "trebek_1935.npy\n", + "(1, 80, 225)\n", + "trebek_1004.npy\n", + "(1, 80, 866)\n", + "trebek_2304.npy\n", + "(1, 80, 500)\n", + "trebek_628.npy\n", + "(1, 80, 649)\n", + "trebek_675.npy\n", + "(1, 80, 466)\n", + "trebek_1292.npy\n", + "(1, 80, 548)\n", + "trebek_1340.npy\n", + "(1, 80, 533)\n", + "trebek_335.npy\n", + "(1, 80, 590)\n", + "trebek_2280.npy\n", + "(1, 80, 399)\n", + "trebek_2071.npy\n", + "(1, 80, 783)\n", + "trebek_1629.npy\n", + "(1, 80, 535)\n", + "trebek_1612.npy\n", + "(1, 80, 778)\n", + "trebek_711.npy\n", + "(1, 80, 481)\n", + "trebek_813.npy\n", + "(1, 80, 675)\n", + "trebek_544.npy\n", + "(1, 80, 401)\n", + "trebek_2510.npy\n", + "(1, 80, 512)\n", + "trebek_1796.npy\n", + "(1, 80, 473)\n", + "trebek_865.npy\n", + "(1, 80, 609)\n", + "trebek_1880.npy\n", + "(1, 80, 440)\n", + "trebek_1080.npy\n", + "(1, 80, 631)\n", + "trebek_2186.npy\n", + "(1, 80, 499)\n", + "trebek_1352.npy\n", + "(1, 80, 608)\n", + "trebek_2340.npy\n", + "(1, 80, 420)\n", + "trebek_690.npy\n", + "(1, 80, 683)\n", + "trebek_2015.npy\n", + "(1, 80, 727)\n", + "trebek_195.npy\n", + "(1, 80, 734)\n", + "trebek_1763.npy\n", + "(1, 80, 588)\n", + "trebek_1974.npy\n", + "(1, 80, 559)\n", + "trebek_1507.npy\n", + "(1, 80, 486)\n", + "trebek_387.npy\n", + "(1, 80, 476)\n", + "trebek_220.npy\n", + "(1, 80, 349)\n", + "trebek_927.npy\n", + "(1, 80, 689)\n", + "trebek_289.npy\n", + "(1, 80, 608)\n", + "trebek_300.npy\n", + "(1, 80, 905)\n", + "trebek_506.npy\n", + "(1, 80, 530)\n", + "trebek_75.npy\n", + "(1, 80, 659)\n", + "trebek_1528.npy\n", + "(1, 80, 417)\n", + "trebek_1499.npy\n", + "(1, 80, 623)\n", + "trebek_516.npy\n", + "(1, 80, 512)\n", + "trebek_1792.npy\n", + "(1, 80, 851)\n", + "trebek_2179.npy\n", + "(1, 80, 450)\n", + "trebek_1325.npy\n", + "(1, 80, 686)\n", + "trebek_703.npy\n", + "(1, 80, 335)\n", + "trebek_2115.npy\n", + "(1, 80, 815)\n", + "trebek_2231.npy\n", + "(1, 80, 613)\n", + "trebek_2048.npy\n", + "(1, 80, 812)\n", + "trebek_755.npy\n", + "(1, 80, 703)\n", + "trebek_535.npy\n", + "(1, 80, 727)\n", + "trebek_1761.npy\n", + "(1, 80, 709)\n", + "trebek_299.npy\n", + "(1, 80, 598)\n", + "trebek_385.npy\n", + "(1, 80, 396)\n", + "trebek_391.npy\n", + "(1, 80, 659)\n", + "trebek_2139.npy\n", + "(1, 80, 584)\n", + "trebek_487.npy\n", + "(1, 80, 437)\n", + "trebek_2351.npy\n", + "(1, 80, 487)\n", + "trebek_1175.npy\n", + "(1, 80, 634)\n", + "trebek_1603.npy\n", + "(1, 80, 264)\n", + "trebek_2310.npy\n", + "(1, 80, 331)\n", + "trebek_502.npy\n", + "(1, 80, 370)\n", + "trebek_434.npy\n", + "(1, 80, 565)\n", + "trebek_1635.npy\n", + "(1, 80, 513)\n", + "trebek_2012.npy\n", + "(1, 80, 888)\n", + "trebek_349.npy\n", + "(1, 80, 504)\n", + "trebek_1218.npy\n", + "(1, 80, 675)\n", + "trebek_1305.npy\n", + "(1, 80, 432)\n", + "trebek_988.npy\n", + "(1, 80, 318)\n", + "trebek_995.npy\n", + "(1, 80, 243)\n", + "trebek_1290.npy\n", + "(1, 80, 690)\n", + "trebek_525.npy\n", + "(1, 80, 553)\n", + "trebek_1169.npy\n", + "(1, 80, 657)\n", + "trebek_2031.npy\n", + "(1, 80, 610)\n", + "trebek_249.npy\n", + "(1, 80, 827)\n", + "trebek_198.npy\n", + "(1, 80, 502)\n", + "trebek_2171.npy\n", + "(1, 80, 624)\n", + "trebek_1862.npy\n", + "(1, 80, 316)\n", + "trebek_536.npy\n", + "(1, 80, 608)\n", + "trebek_2013.npy\n", + "(1, 80, 471)\n", + "trebek_106.npy\n", + "(1, 80, 515)\n", + "trebek_1003.npy\n", + "(1, 80, 321)\n", + "trebek_2201.npy\n", + "(1, 80, 458)\n", + "trebek_110.npy\n", + "(1, 80, 375)\n", + "trebek_1760.npy\n", + "(1, 80, 639)\n", + "trebek_154.npy\n", + "(1, 80, 515)\n", + "trebek_498.npy\n", + "(1, 80, 479)\n", + "trebek_915.npy\n", + "(1, 80, 481)\n", + "trebek_1654.npy\n", + "(1, 80, 693)\n", + "trebek_796.npy\n", + "(1, 80, 406)\n", + "trebek_1184.npy\n", + "(1, 80, 732)\n", + "trebek_453.npy\n", + "(1, 80, 536)\n", + "trebek_1345.npy\n", + "(1, 80, 781)\n", + "trebek_1680.npy\n", + "(1, 80, 344)\n", + "trebek_334.npy\n", + "(1, 80, 629)\n", + "trebek_321.npy\n", + "(1, 80, 553)\n", + "trebek_1355.npy\n", + "(1, 80, 585)\n", + "trebek_854.npy\n", + "(1, 80, 623)\n", + "trebek_1335.npy\n", + "(1, 80, 636)\n", + "trebek_875.npy\n", + "(1, 80, 564)\n", + "trebek_984.npy\n", + "(1, 80, 561)\n", + "trebek_1681.npy\n", + "(1, 80, 357)\n", + "trebek_987.npy\n", + "(1, 80, 437)\n", + "trebek_2257.npy\n", + "(1, 80, 373)\n", + "trebek_1812.npy\n", + "(1, 80, 820)\n", + "trebek_2375.npy\n", + "(1, 80, 407)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "trebek_572.npy\n", + "(1, 80, 649)\n", + "trebek_1737.npy\n", + "(1, 80, 486)\n", + "trebek_1837.npy\n", + "(1, 80, 615)\n", + "trebek_912.npy\n", + "(1, 80, 422)\n", + "trebek_575.npy\n", + "(1, 80, 647)\n", + "trebek_1406.npy\n", + "(1, 80, 494)\n", + "trebek_409.npy\n", + "(1, 80, 626)\n", + "trebek_2434.npy\n", + "(1, 80, 446)\n", + "trebek_2054.npy\n", + "(1, 80, 538)\n", + "trebek_1412.npy\n", + "(1, 80, 404)\n", + "trebek_2359.npy\n", + "(1, 80, 890)\n", + "trebek_1285.npy\n", + "(1, 80, 587)\n", + "trebek_1573.npy\n", + "(1, 80, 538)\n", + "trebek_1429.npy\n", + "(1, 80, 409)\n", + "trebek_876.npy\n", + "(1, 80, 670)\n", + "trebek_1952.npy\n", + "(1, 80, 339)\n", + "trebek_175.npy\n", + "(1, 80, 614)\n", + "trebek_959.npy\n", + "(1, 80, 507)\n", + "trebek_234.npy\n", + "(1, 80, 714)\n", + "trebek_1691.npy\n", + "(1, 80, 565)\n", + "trebek_1882.npy\n", + "(1, 80, 804)\n", + "trebek_92.npy\n", + "(1, 80, 425)\n", + "trebek_1980.npy\n", + "(1, 80, 569)\n", + "trebek_81.npy\n", + "(1, 80, 282)\n", + "trebek_2066.npy\n", + "(1, 80, 647)\n", + "trebek_403.npy\n", + "(1, 80, 541)\n", + "trebek_1778.npy\n", + "(1, 80, 752)\n", + "trebek_8.npy\n", + "(1, 80, 632)\n", + "trebek_1384.npy\n", + "(1, 80, 548)\n", + "trebek_1481.npy\n", + "(1, 80, 360)\n", + "trebek_2469.npy\n", + "(1, 80, 427)\n", + "trebek_291.npy\n", + "(1, 80, 393)\n", + "trebek_1879.npy\n", + "(1, 80, 678)\n", + "trebek_2193.npy\n", + "(1, 80, 613)\n", + "trebek_1605.npy\n", + "(1, 80, 505)\n", + "trebek_412.npy\n", + "(1, 80, 466)\n", + "trebek_2043.npy\n", + "(1, 80, 640)\n", + "trebek_1155.npy\n", + "(1, 80, 522)\n", + "trebek_902.npy\n", + "(1, 80, 654)\n", + "trebek_2495.npy\n", + "(1, 80, 383)\n", + "trebek_1390.npy\n", + "(1, 80, 578)\n", + "trebek_414.npy\n", + "(1, 80, 491)\n", + "trebek_1158.npy\n", + "(1, 80, 459)\n", + "trebek_917.npy\n", + "(1, 80, 474)\n", + "trebek_748.npy\n", + "(1, 80, 701)\n", + "trebek_323.npy\n", + "(1, 80, 497)\n", + "trebek_2504.npy\n", + "(1, 80, 487)\n", + "trebek_2563.npy\n", + "(1, 80, 362)\n", + "trebek_1758.npy\n", + "(1, 80, 747)\n", + "trebek_2225.npy\n", + "(1, 80, 424)\n", + "trebek_905.npy\n", + "(1, 80, 751)\n", + "trebek_1820.npy\n", + "(1, 80, 373)\n", + "trebek_1489.npy\n", + "(1, 80, 636)\n", + "trebek_1585.npy\n", + "(1, 80, 308)\n", + "trebek_1093.npy\n", + "(1, 80, 683)\n", + "trebek_123.npy\n", + "(1, 80, 743)\n", + "trebek_2024.npy\n", + "(1, 80, 796)\n", + "trebek_653.npy\n", + "(1, 80, 621)\n", + "trebek_1495.npy\n", + "(1, 80, 424)\n", + "trebek_567.npy\n", + "(1, 80, 440)\n", + "trebek_190.npy\n", + "(1, 80, 730)\n", + "trebek_1898.npy\n", + "(1, 80, 474)\n", + "trebek_897.npy\n", + "(1, 80, 531)\n", + "trebek_2318.npy\n", + "(1, 80, 267)\n", + "trebek_1135.npy\n", + "(1, 80, 445)\n", + "trebek_733.npy\n", + "(1, 80, 414)\n", + "trebek_330.npy\n", + "(1, 80, 521)\n", + "trebek_1753.npy\n", + "(1, 80, 370)\n", + "trebek_13.npy\n", + "(1, 80, 779)\n", + "trebek_708.npy\n", + "(1, 80, 438)\n", + "trebek_1575.npy\n", + "(1, 80, 709)\n", + "trebek_1064.npy\n", + "(1, 80, 562)\n", + "trebek_926.npy\n", + "(1, 80, 696)\n", + "trebek_685.npy\n", + "(1, 80, 424)\n", + "trebek_523.npy\n", + "(1, 80, 822)\n", + "trebek_2202.npy\n", + "(1, 80, 463)\n", + "trebek_1118.npy\n", + "(1, 80, 771)\n", + "trebek_925.npy\n", + "(1, 80, 898)\n", + "trebek_1326.npy\n", + "(1, 80, 603)\n", + "trebek_1955.npy\n", + "(1, 80, 582)\n", + "trebek_438.npy\n", + "(1, 80, 580)\n", + "trebek_1085.npy\n", + "(1, 80, 504)\n", + "trebek_1545.npy\n", + "(1, 80, 913)\n", + "trebek_1104.npy\n", + "(1, 80, 471)\n", + "trebek_2076.npy\n", + "(1, 80, 678)\n", + "trebek_2281.npy\n", + "(1, 80, 398)\n", + "trebek_530.npy\n", + "(1, 80, 972)\n", + "trebek_2190.npy\n", + "(1, 80, 515)\n", + "trebek_1557.npy\n", + "(1, 80, 622)\n", + "trebek_2288.npy\n", + "(1, 80, 637)\n", + "trebek_1827.npy\n", + "(1, 80, 704)\n", + "trebek_916.npy\n", + "(1, 80, 409)\n", + "trebek_482.npy\n", + "(1, 80, 706)\n", + "trebek_2506.npy\n", + "(1, 80, 592)\n", + "trebek_494.npy\n", + "(1, 80, 781)\n", + "trebek_1731.npy\n", + "(1, 80, 432)\n", + "trebek_2350.npy\n", + "(1, 80, 683)\n", + "trebek_254.npy\n", + "(1, 80, 590)\n", + "trebek_1544.npy\n", + "(1, 80, 505)\n", + "trebek_274.npy\n", + "(1, 80, 381)\n", + "trebek_1795.npy\n", + "(1, 80, 590)\n", + "trebek_2230.npy\n", + "(1, 80, 618)\n", + "trebek_372.npy\n", + "(1, 80, 786)\n", + "trebek_2114.npy\n", + "(1, 80, 365)\n", + "trebek_2118.npy\n", + "(1, 80, 807)\n", + "trebek_2526.npy\n", + "(1, 80, 575)\n", + "trebek_336.npy\n", + "(1, 80, 827)\n", + "trebek_1391.npy\n", + "(1, 80, 396)\n", + "trebek_687.npy\n", + "(1, 80, 665)\n", + "trebek_2319.npy\n", + "(1, 80, 528)\n", + "trebek_236.npy\n", + "(1, 80, 839)\n", + "trebek_2137.npy\n", + "(1, 80, 460)\n", + "trebek_1057.npy\n", + "(1, 80, 720)\n", + "trebek_2040.npy\n", + "(1, 80, 367)\n", + "trebek_2099.npy\n", + "(1, 80, 711)\n", + "trebek_818.npy\n", + "(1, 80, 530)\n", + "trebek_1072.npy\n", + "(1, 80, 468)\n", + "trebek_1046.npy\n", + "(1, 80, 497)\n", + "trebek_1302.npy\n", + "(1, 80, 610)\n", + "trebek_223.npy\n", + "(1, 80, 516)\n", + "trebek_1850.npy\n", + "(1, 80, 556)\n", + "trebek_1022.npy\n", + "(1, 80, 551)\n", + "trebek_2127.npy\n", + "(1, 80, 541)\n", + "trebek_363.npy\n", + "(1, 80, 560)\n", + "trebek_452.npy\n", + "(1, 80, 683)\n", + "trebek_124.npy\n", + "(1, 80, 479)\n", + "trebek_1779.npy\n", + "(1, 80, 644)\n", + "trebek_2182.npy\n", + "(1, 80, 298)\n", + "trebek_74.npy\n", + "(1, 80, 716)\n", + "trebek_2113.npy\n", + "(1, 80, 491)\n", + "trebek_2365.npy\n", + "(1, 80, 621)\n", + "trebek_1534.npy\n", + "(1, 80, 422)\n", + "trebek_736.npy\n", + "(1, 80, 667)\n", + "trebek_137.npy\n", + "(1, 80, 629)\n", + "trebek_2067.npy\n", + "(1, 80, 584)\n", + "trebek_946.npy\n", + "(1, 80, 335)\n", + "trebek_586.npy\n", + "(1, 80, 610)\n", + "trebek_2394.npy\n", + "(1, 80, 592)\n", + "trebek_1963.npy\n", + "(1, 80, 689)\n", + "trebek_1636.npy\n", + "(1, 80, 644)\n", + "trebek_2144.npy\n", + "(1, 80, 662)\n", + "trebek_447.npy\n", + "(1, 80, 564)\n", + "trebek_1356.npy\n", + "(1, 80, 848)\n", + "trebek_1616.npy\n", + "(1, 80, 502)\n", + "trebek_2290.npy\n", + "(1, 80, 652)\n", + "trebek_1464.npy\n", + "(1, 80, 406)\n", + "trebek_2384.npy\n", + "(1, 80, 676)\n", + "trebek_1414.npy\n", + "(1, 80, 486)\n", + "trebek_1280.npy\n", + "(1, 80, 590)\n", + "trebek_2536.npy\n", + "(1, 80, 461)\n", + "trebek_2161.npy\n", + "(1, 80, 574)\n", + "trebek_971.npy\n", + "(1, 80, 543)\n", + "trebek_400.npy\n", + "(1, 80, 805)\n", + "trebek_2414.npy\n", + "(1, 80, 543)\n", + "trebek_58.npy\n", + "(1, 80, 736)\n", + "trebek_1699.npy\n", + "(1, 80, 605)\n", + "trebek_2250.npy\n", + "(1, 80, 683)\n", + "trebek_1497.npy\n", + "(1, 80, 453)\n", + "trebek_1505.npy\n", + "(1, 80, 423)\n", + "trebek_990.npy\n", + "(1, 80, 382)\n", + "trebek_1684.npy\n", + "(1, 80, 484)\n", + "trebek_2008.npy\n", + "(1, 80, 473)\n", + "trebek_601.npy\n", + "(1, 80, 601)\n", + "trebek_870.npy\n", + "(1, 80, 608)\n", + "trebek_1546.npy\n", + "(1, 80, 665)\n", + "trebek_1614.npy\n", + "(1, 80, 601)\n", + "trebek_833.npy\n", + "(1, 80, 791)\n", + "trebek_1859.npy\n", + "(1, 80, 694)\n", + "trebek_277.npy\n", + "(1, 80, 689)\n", + "trebek_1715.npy\n", + "(1, 80, 429)\n", + "trebek_2300.npy\n", + "(1, 80, 557)\n", + "trebek_1318.npy\n", + "(1, 80, 553)\n", + "trebek_1519.npy\n", + "(1, 80, 554)\n", + "trebek_1095.npy\n", + "(1, 80, 640)\n", + "trebek_26.npy\n", + "(1, 80, 835)\n", + "trebek_296.npy\n", + "(1, 80, 747)\n", + "trebek_229.npy\n", + "(1, 80, 784)\n", + "trebek_825.npy\n", + "(1, 80, 649)\n", + "trebek_1841.npy\n", + "(1, 80, 654)\n", + "trebek_1671.npy\n", + "(1, 80, 494)\n", + "trebek_538.npy\n", + "(1, 80, 683)\n", + "trebek_2508.npy\n", + "(1, 80, 553)\n", + "trebek_983.npy\n", + "(1, 80, 665)\n", + "trebek_1009.npy\n", + "(1, 80, 569)\n", + "trebek_1024.npy\n", + "(1, 80, 624)\n", + "trebek_1455.npy\n", + "(1, 80, 608)\n", + "trebek_1702.npy\n", + "(1, 80, 707)\n", + "trebek_2505.npy\n", + "(1, 80, 448)\n", + "trebek_1415.npy\n", + "(1, 80, 740)\n", + "trebek_1564.npy\n", + "(1, 80, 292)\n", + "trebek_1428.npy\n", + "(1, 80, 590)\n", + "trebek_741.npy\n", + "(1, 80, 600)\n", + "trebek_2552.npy\n", + "(1, 80, 577)\n", + "trebek_2140.npy\n", + "(1, 80, 662)\n", + "trebek_532.npy\n", + "(1, 80, 813)\n", + "trebek_2205.npy\n", + "(1, 80, 497)\n", + "trebek_2146.npy\n", + "(1, 80, 732)\n", + "trebek_1967.npy\n", + "(1, 80, 570)\n", + "trebek_590.npy\n", + "(1, 80, 735)\n", + "trebek_2496.npy\n", + "(1, 80, 287)\n", + "trebek_162.npy\n", + "(1, 80, 738)\n", + "trebek_1933.npy\n", + "(1, 80, 662)\n", + "trebek_1162.npy\n", + "(1, 80, 429)\n", + "trebek_2491.npy\n", + "(1, 80, 352)\n", + "trebek_542.npy\n", + "(1, 80, 696)\n", + "trebek_1553.npy\n", + "(1, 80, 636)\n", + "trebek_211.npy\n", + "(1, 80, 693)\n", + "trebek_2387.npy\n", + "(1, 80, 458)\n", + "trebek_1759.npy\n", + "(1, 80, 593)\n", + "trebek_2358.npy\n", + "(1, 80, 608)\n", + "trebek_421.npy\n", + "(1, 80, 520)\n", + "trebek_1620.npy\n", + "(1, 80, 528)\n", + "trebek_2455.npy\n", + "(1, 80, 579)\n", + "trebek_2543.npy\n", + "(1, 80, 383)\n", + "trebek_1084.npy\n", + "(1, 80, 460)\n", + "trebek_1960.npy\n", + "(1, 80, 246)\n", + "trebek_964.npy\n", + "(1, 80, 546)\n", + "trebek_1132.npy\n", + "(1, 80, 371)\n", + "trebek_1106.npy\n", + "(1, 80, 690)\n", + "trebek_1181.npy\n", + "(1, 80, 515)\n", + "trebek_2075.npy\n", + "(1, 80, 640)\n", + "trebek_1015.npy\n", + "(1, 80, 701)\n", + "trebek_1667.npy\n", + "(1, 80, 642)\n", + "trebek_1477.npy\n", + "(1, 80, 497)\n", + "trebek_1945.npy\n", + "(1, 80, 437)\n", + "trebek_2104.npy\n", + "(1, 80, 525)\n", + "trebek_1962.npy\n", + "(1, 80, 758)\n", + "trebek_441.npy\n", + "(1, 80, 548)\n", + "trebek_790.npy\n", + "(1, 80, 812)\n", + "trebek_365.npy\n", + "(1, 80, 535)\n", + "trebek_1367.npy\n", + "(1, 80, 825)\n", + "trebek_480.npy\n", + "(1, 80, 569)\n", + "trebek_2332.npy\n", + "(1, 80, 450)\n", + "trebek_2243.npy\n", + "(1, 80, 277)\n", + "trebek_1090.npy\n", + "(1, 80, 742)\n", + "trebek_1441.npy\n", + "(1, 80, 373)\n", + "trebek_1295.npy\n", + "(1, 80, 724)\n", + "trebek_1440.npy\n", + "(1, 80, 376)\n", + "trebek_2516.npy\n", + "(1, 80, 701)\n", + "trebek_143.npy\n", + "(1, 80, 644)\n", + "trebek_2260.npy\n", + "(1, 80, 530)\n", + "trebek_2258.npy\n", + "(1, 80, 424)\n", + "trebek_610.npy\n", + "(1, 80, 714)\n", + "trebek_623.npy\n", + "(1, 80, 422)\n", + "trebek_1981.npy\n", + "(1, 80, 671)\n", + "trebek_1810.npy\n", + "(1, 80, 484)\n", + "trebek_301.npy\n", + "(1, 80, 685)\n", + "trebek_2152.npy\n", + "(1, 80, 750)\n", + "trebek_671.npy\n", + "(1, 80, 907)\n", + "trebek_366.npy\n", + "(1, 80, 618)\n", + "trebek_1065.npy\n", + "(1, 80, 740)\n", + "trebek_1712.npy\n", + "(1, 80, 579)\n", + "trebek_932.npy\n", + "(1, 80, 699)\n", + "trebek_423.npy\n", + "(1, 80, 479)\n", + "trebek_1201.npy\n", + "(1, 80, 685)\n", + "trebek_1717.npy\n", + "(1, 80, 414)\n", + "trebek_1728.npy\n", + "(1, 80, 809)\n", + "trebek_758.npy\n", + "(1, 80, 582)\n", + "trebek_85.npy\n", + "(1, 80, 919)\n", + "trebek_158.npy\n", + "(1, 80, 582)\n", + "trebek_1936.npy\n", + "(1, 80, 722)\n", + "trebek_584.npy\n", + "(1, 80, 365)\n", + "trebek_310.npy\n", + "(1, 80, 543)\n", + "trebek_2298.npy\n", + "(1, 80, 582)\n", + "trebek_1243.npy\n", + "(1, 80, 727)\n", + "trebek_107.npy\n", + "(1, 80, 746)\n", + "trebek_212.npy\n", + "(1, 80, 760)\n", + "trebek_1188.npy\n", + "(1, 80, 528)\n", + "trebek_2219.npy\n", + "(1, 80, 615)\n", + "trebek_2443.npy\n", + "(1, 80, 553)\n", + "trebek_1526.npy\n", + "(1, 80, 442)\n", + "trebek_1437.npy\n", + "(1, 80, 404)\n", + "trebek_2109.npy\n", + "(1, 80, 693)\n", + "trebek_1309.npy\n", + "(1, 80, 502)\n", + "trebek_1884.npy\n", + "(1, 80, 799)\n", + "trebek_176.npy\n", + "(1, 80, 608)\n", + "trebek_2248.npy\n", + "(1, 80, 768)\n", + "trebek_774.npy\n", + "(1, 80, 497)\n", + "trebek_1151.npy\n", + "(1, 80, 681)\n", + "trebek_2383.npy\n", + "(1, 80, 342)\n", + "trebek_688.npy\n", + "(1, 80, 410)\n", + "trebek_2540.npy\n", + "(1, 80, 305)\n", + "trebek_900.npy\n", + "(1, 80, 597)\n", + "trebek_2053.npy\n", + "(1, 80, 443)\n", + "trebek_823.npy\n", + "(1, 80, 536)\n", + "trebek_1583.npy\n", + "(1, 80, 448)\n", + "trebek_717.npy\n", + "(1, 80, 455)\n", + "trebek_1235.npy\n", + "(1, 80, 230)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "trebek_2158.npy\n", + "(1, 80, 613)\n", + "trebek_1083.npy\n", + "(1, 80, 422)\n", + "trebek_836.npy\n", + "(1, 80, 649)\n", + "trebek_976.npy\n", + "(1, 80, 584)\n", + "trebek_1350.npy\n", + "(1, 80, 657)\n", + "trebek_2418.npy\n", + "(1, 80, 556)\n", + "trebek_1661.npy\n", + "(1, 80, 627)\n", + "trebek_133.npy\n", + "(1, 80, 484)\n", + "trebek_1223.npy\n", + "(1, 80, 815)\n", + "trebek_2441.npy\n", + "(1, 80, 525)\n", + "trebek_2030.npy\n", + "(1, 80, 634)\n", + "trebek_1762.npy\n", + "(1, 80, 553)\n", + "trebek_1774.npy\n", + "(1, 80, 892)\n", + "trebek_2489.npy\n", + "(1, 80, 461)\n", + "trebek_1226.npy\n", + "(1, 80, 596)\n", + "trebek_1868.npy\n", + "(1, 80, 709)\n", + "trebek_1237.npy\n", + "(1, 80, 601)\n", + "trebek_2138.npy\n", + "(1, 80, 487)\n", + "trebek_923.npy\n", + "(1, 80, 535)\n", + "trebek_781.npy\n", + "(1, 80, 451)\n", + "trebek_2120.npy\n", + "(1, 80, 662)\n", + "trebek_1572.npy\n", + "(1, 80, 336)\n", + "trebek_1786.npy\n", + "(1, 80, 764)\n", + "trebek_394.npy\n", + "(1, 80, 515)\n", + "trebek_804.npy\n", + "(1, 80, 533)\n", + "trebek_1520.npy\n", + "(1, 80, 349)\n", + "trebek_1278.npy\n", + "(1, 80, 535)\n", + "trebek_993.npy\n", + "(1, 80, 243)\n", + "trebek_583.npy\n", + "(1, 80, 614)\n", + "trebek_2527.npy\n", + "(1, 80, 489)\n", + "trebek_95.npy\n", + "(1, 80, 321)\n", + "trebek_251.npy\n", + "(1, 80, 336)\n", + "trebek_164.npy\n", + "(1, 80, 618)\n", + "trebek_1842.npy\n", + "(1, 80, 311)\n", + "trebek_2549.npy\n", + "(1, 80, 559)\n", + "trebek_1291.npy\n", + "(1, 80, 497)\n", + "trebek_1509.npy\n", + "(1, 80, 616)\n", + "trebek_456.npy\n", + "(1, 80, 606)\n", + "trebek_2395.npy\n", + "(1, 80, 559)\n", + "trebek_1018.npy\n", + "(1, 80, 355)\n", + "trebek_390.npy\n", + "(1, 80, 508)\n", + "trebek_667.npy\n", + "(1, 80, 525)\n", + "trebek_2341.npy\n", + "(1, 80, 765)\n", + "trebek_1590.npy\n", + "(1, 80, 693)\n", + "trebek_715.npy\n", + "(1, 80, 574)\n", + "trebek_1682.npy\n", + "(1, 80, 590)\n", + "trebek_1937.npy\n", + "(1, 80, 657)\n", + "trebek_648.npy\n", + "(1, 80, 512)\n", + "trebek_1327.npy\n", + "(1, 80, 747)\n", + "trebek_1418.npy\n", + "(1, 80, 481)\n", + "trebek_342.npy\n", + "(1, 80, 652)\n", + "trebek_949.npy\n", + "(1, 80, 445)\n", + "trebek_227.npy\n", + "(1, 80, 760)\n", + "trebek_1609.npy\n", + "(1, 80, 251)\n", + "trebek_464.npy\n", + "(1, 80, 913)\n", + "trebek_1459.npy\n", + "(1, 80, 373)\n", + "trebek_1767.npy\n", + "(1, 80, 752)\n", + "trebek_1559.npy\n", + "(1, 80, 424)\n", + "trebek_637.npy\n", + "(1, 80, 804)\n", + "trebek_1894.npy\n", + "(1, 80, 711)\n", + "trebek_2111.npy\n", + "(1, 80, 569)\n", + "trebek_526.npy\n", + "(1, 80, 675)\n", + "trebek_815.npy\n", + "(1, 80, 784)\n", + "trebek_2361.npy\n", + "(1, 80, 631)\n", + "trebek_1650.npy\n", + "(1, 80, 364)\n", + "trebek_1914.npy\n", + "(1, 80, 205)\n", + "trebek_605.npy\n", + "(1, 80, 634)\n", + "trebek_449.npy\n", + "(1, 80, 410)\n", + "trebek_620.npy\n", + "(1, 80, 693)\n", + "trebek_2197.npy\n", + "(1, 80, 339)\n", + "trebek_1192.npy\n", + "(1, 80, 592)\n", + "trebek_2279.npy\n", + "(1, 80, 184)\n", + "trebek_563.npy\n", + "(1, 80, 596)\n", + "trebek_1741.npy\n", + "(1, 80, 551)\n", + "trebek_1281.npy\n", + "(1, 80, 698)\n", + "trebek_1373.npy\n", + "(1, 80, 760)\n", + "trebek_357.npy\n", + "(1, 80, 654)\n", + "trebek_1423.npy\n", + "(1, 80, 339)\n", + "trebek_767.npy\n", + "(1, 80, 659)\n", + "trebek_930.npy\n", + "(1, 80, 595)\n", + "trebek_2315.npy\n", + "(1, 80, 678)\n", + "trebek_306.npy\n", + "(1, 80, 559)\n", + "trebek_1173.npy\n", + "(1, 80, 737)\n", + "trebek_2091.npy\n", + "(1, 80, 678)\n", + "trebek_2419.npy\n", + "(1, 80, 786)\n", + "trebek_2529.npy\n", + "(1, 80, 546)\n", + "trebek_79.npy\n", + "(1, 80, 938)\n", + "trebek_1068.npy\n", + "(1, 80, 393)\n", + "trebek_1316.npy\n", + "(1, 80, 515)\n", + "trebek_2382.npy\n", + "(1, 80, 414)\n", + "trebek_1344.npy\n", + "(1, 80, 670)\n", + "trebek_2210.npy\n", + "(1, 80, 752)\n", + "trebek_1333.npy\n", + "(1, 80, 528)\n", + "trebek_1263.npy\n", + "(1, 80, 308)\n", + "trebek_1982.npy\n", + "(1, 80, 752)\n", + "trebek_1063.npy\n", + "(1, 80, 678)\n", + "trebek_1854.npy\n", + "(1, 80, 582)\n", + "trebek_2539.npy\n", + "(1, 80, 393)\n", + "trebek_643.npy\n", + "(1, 80, 724)\n", + "trebek_2103.npy\n", + "(1, 80, 424)\n", + "trebek_80.npy\n", + "(1, 80, 843)\n", + "trebek_1828.npy\n", + "(1, 80, 618)\n", + "trebek_1872.npy\n", + "(1, 80, 747)\n", + "trebek_370.npy\n", + "(1, 80, 584)\n", + "trebek_939.npy\n", + "(1, 80, 678)\n", + "trebek_1958.npy\n", + "(1, 80, 448)\n", + "trebek_1950.npy\n", + "(1, 80, 752)\n", + "trebek_654.npy\n", + "(1, 80, 378)\n", + "trebek_477.npy\n", + "(1, 80, 658)\n", + "trebek_2378.npy\n", + "(1, 80, 409)\n", + "trebek_1050.npy\n", + "(1, 80, 684)\n", + "trebek_1997.npy\n", + "(1, 80, 714)\n", + "trebek_2148.npy\n", + "(1, 80, 725)\n", + "trebek_2200.npy\n", + "(1, 80, 570)\n", + "trebek_257.npy\n", + "(1, 80, 416)\n", + "trebek_885.npy\n", + "(1, 80, 452)\n", + "trebek_1284.npy\n", + "(1, 80, 586)\n", + "trebek_2393.npy\n", + "(1, 80, 389)\n", + "trebek_2518.npy\n", + "(1, 80, 344)\n", + "trebek_614.npy\n", + "(1, 80, 549)\n", + "trebek_375.npy\n", + "(1, 80, 629)\n", + "trebek_1207.npy\n", + "(1, 80, 507)\n", + "trebek_1229.npy\n", + "(1, 80, 706)\n", + "trebek_868.npy\n", + "(1, 80, 672)\n", + "trebek_778.npy\n", + "(1, 80, 574)\n", + "trebek_451.npy\n", + "(1, 80, 437)\n", + "trebek_242.npy\n", + "(1, 80, 826)\n", + "trebek_1167.npy\n", + "(1, 80, 391)\n", + "trebek_1076.npy\n", + "(1, 80, 481)\n", + "trebek_2392.npy\n", + "(1, 80, 473)\n", + "trebek_2532.npy\n", + "(1, 80, 556)\n", + "trebek_1134.npy\n", + "(1, 80, 639)\n", + "trebek_1416.npy\n", + "(1, 80, 572)\n", + "trebek_1098.npy\n", + "(1, 80, 484)\n", + "trebek_802.npy\n", + "(1, 80, 645)\n", + "trebek_1206.npy\n", + "(1, 80, 411)\n", + "trebek_1625.npy\n", + "(1, 80, 548)\n", + "trebek_2343.npy\n", + "(1, 80, 630)\n", + "trebek_1177.npy\n", + "(1, 80, 858)\n", + "trebek_173.npy\n", + "(1, 80, 657)\n", + "trebek_1094.npy\n", + "(1, 80, 719)\n", + "trebek_1166.npy\n", + "(1, 80, 352)\n", + "trebek_1921.npy\n", + "(1, 80, 787)\n", + "trebek_247.npy\n", + "(1, 80, 628)\n", + "trebek_632.npy\n", + "(1, 80, 747)\n", + "trebek_1685.npy\n", + "(1, 80, 756)\n" + ] + }, + { + "ename": "IndexError", + "evalue": "Dimension out of range (expected to be in range of [-1, 0], but got 1)", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbatch\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata_loader\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnum_items\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbatch_to_gpu\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbatch\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mout\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 8\u001b[0m \u001b[0mmel_out\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmel_out_postnet\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgate_outs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0malignments\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/anaconda3/envs/pytorch_p36/lib/python3.6/site-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 725\u001b[0m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_slow_forward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 726\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 727\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 728\u001b[0m for hook in itertools.chain(\n\u001b[1;32m 729\u001b[0m \u001b[0m_global_forward_hooks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/DeepLearningExamples/PyTorch/SpeechSynthesis/Tacotron2/tacotron2/model.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, inputs)\u001b[0m\n\u001b[1;32m 666\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 667\u001b[0m mel_outputs, gate_outputs, alignments = self.decoder(\n\u001b[0;32m--> 668\u001b[0;31m encoder_outputs, targets, memory_lengths=input_lengths)\n\u001b[0m\u001b[1;32m 669\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 670\u001b[0m \u001b[0mmel_outputs_postnet\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpostnet\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmel_outputs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/anaconda3/envs/pytorch_p36/lib/python3.6/site-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 725\u001b[0m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_slow_forward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 726\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 727\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 728\u001b[0m for hook in itertools.chain(\n\u001b[1;32m 729\u001b[0m \u001b[0m_global_forward_hooks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/DeepLearningExamples/PyTorch/SpeechSynthesis/Tacotron2/tacotron2/model.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, memory, decoder_inputs, memory_lengths)\u001b[0m\n\u001b[1;32m 508\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstack\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmel_outputs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 509\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstack\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgate_outputs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 510\u001b[0;31m torch.stack(alignments))\n\u001b[0m\u001b[1;32m 511\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 512\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mmel_outputs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgate_outputs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0malignments\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/DeepLearningExamples/PyTorch/SpeechSynthesis/Tacotron2/tacotron2/model.py\u001b[0m in \u001b[0;36mparse_decoder_outputs\u001b[0;34m(self, mel_outputs, gate_outputs, alignments)\u001b[0m\n\u001b[1;32m 387\u001b[0m \u001b[0malignments\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0malignments\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtranspose\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcontiguous\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 388\u001b[0m \u001b[0;31m# (T_out, B) -> (B, T_out)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 389\u001b[0;31m \u001b[0mgate_outputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgate_outputs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtranspose\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcontiguous\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 390\u001b[0m \u001b[0;31m# (T_out, B, n_mel_channels) -> (B, T_out, n_mel_channels)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 391\u001b[0m \u001b[0mmel_outputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmel_outputs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtranspose\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcontiguous\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mIndexError\u001b[0m: Dimension out of range (expected to be in range of [-1, 0], but got 1)" + ] + } + ], + "source": [ + "idx = 0\n", + "model.eval()\n", + "tf_dir = \"/home/ubuntu/hg_tune_data/mels\"\n", + "with torch.no_grad():\n", + " for i, batch in enumerate(data_loader):\n", + " x, y, num_items = batch_to_gpu(batch)\n", + " out = model(x)\n", + " mel_out, mel_out_postnet, gate_outs, alignments = out\n", + " \n", + " lengths = np.array([len(mel_loader[i][0]) for i in range(idx, idx + mel_out.size(0))])\n", + " apt = np.array([mel_loader.audiopaths_and_text[i] for i in range(idx, idx + mel_out.size(0))])\n", + " apt = apt[np.argsort(lengths)[::-1]]\n", + " \n", + " output_lengths = batch[4]\n", + " for i, el in enumerate(apt):\n", + " filename = el[0].split(\"/\")[-1].replace(\".pt\", \".npy\")\n", + " print(filename) # filename\n", + " output_length = int(output_lengths[i].item())\n", + " mel = mel_out_postnet[i, :, :output_length].unsqueeze(0).data.cpu().numpy()\n", + " print(mel.shape)\n", + " np.save(os.path.join(tf_dir, filename), mel)\n", + " idx += mel_out.size(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import json\n", + "import hifi_gan\n", + "from hifi_gan.env import AttrDict\n", + "from hifi_gan.inference_e2e import load_checkpoint\n", + "from hifi_gan.meldataset import MAX_WAV_VALUE\n", + "from hifi_gan.models import Generator\n", + "\n", + "def load_hifi_gan(path, device=\"cpu\"):\n", + " dev = torch.device(device)\n", + " with open(os.path.join(path, \"config.json\"), \"r\") as f:\n", + " config = AttrDict(json.load(f))\n", + " generator = Generator(config).to(dev)\n", + " for file in os.listdir(path):\n", + " if file.startswith(\"g_\"):\n", + " gen_filename = file\n", + " state_dict_g = load_checkpoint(os.path.join(path, gen_filename), dev)\n", + " print(state_dict_g.keys())\n", + " generator.load_state_dict(state_dict_g['generator'])\n", + " generator.eval()\n", + " generator.remove_weight_norm()\n", + " return generator" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading '/home/ubuntu/UNIVERSAL_V1/g_02500000'\n", + "Complete.\n", + "dict_keys(['generator'])\n", + "Removing weight norm...\n" + ] + } + ], + "source": [ + "gen = load_hifi_gan(\"/home/ubuntu/UNIVERSAL_V1/\", device=\"cuda\")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'output_lengths' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mMAX_WAV_VALUE\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m28000.0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mlength\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0moutput_lengths\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mitem\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3\u001b[0m \u001b[0m_mel\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmel_out_postnet\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m:\u001b[0m\u001b[0mlength\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0mtensor_cls\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mFloatTensor\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcuda\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mis_available\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcuda\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mFloatTensor\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0my_g_hat\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtensor_cls\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_mel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munsqueeze\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"cuda\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mNameError\u001b[0m: name 'output_lengths' is not defined" + ] + } + ], + "source": [ + "MAX_WAV_VALUE = 28000.0\n", + "length = output_lengths[1].item()\n", + "_mel = mel_out_postnet[1][:, :length].data\n", + "tensor_cls = torch.FloatTensor if not torch.cuda.is_available() else torch.cuda.FloatTensor\n", + "y_g_hat = gen(tensor_cls(_mel.unsqueeze(0)).to(device=\"cuda\"))\n", + "audio = y_g_hat.squeeze()\n", + "# audio = audio * MAX_WAV_VALUE\n", + "audio = audio.unsqueeze(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 84, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Audio(audio.data.cpu().numpy(), rate=22050)" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Audio(\"/home/ubuntu/hg_tune_data/wavs/michaelrosen9-110.wav\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "melspec = torch.load(\"/home/ubuntu/michael-rosen/wavs/michaelrosen9-110.pt\")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "loaded = np.load(\"/home/ubuntu/hg_tune_data/mels/michaelrosen9-110.npy\")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "tensor_cls = torch.FloatTensor if not torch.cuda.is_available() else torch.cuda.FloatTensor\n", + "y_g_hat = gen(tensor_cls(loaded).to(device=\"cuda\"))\n", + "audio = y_g_hat.squeeze()\n", + "# audio = audio * MAX_WAV_VALUE\n", + "audio = audio.unsqueeze(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Audio(audio.data.cpu().numpy(), rate=22050)" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1, 80, 557)" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "loaded.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 52, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Audio(\"/home/ubuntu/michael-rosen/wavs/michaelrosen7_582.wav\")" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "134400" + ] + }, + "execution_count": 59, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(557 - 32) * 256" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([296., 389., 96., 394., 174., 163., 401., 296., 437., 228.])" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "batch[5]" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/home/ubuntu/michael-rosen/wavs/michaelrosen9-110.pt\r\n" + ] + } + ], + "source": [ + "ls ~/michael-rosen/wavs/michaelrosen9-110.pt" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([80, 450])" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "melspec.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1, 80, 557)" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "loaded.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(1, 80, 395)\n", + "torch.Size([80, 395])\n" + ] + } + ], + "source": [ + "print(np.load(\"/home/ubuntu/hg_tune_data/mels/michaelrosen9-107.npy\").shape)\n", + "print(torch.load(\"/home/ubuntu/michael-rosen/wavs/michaelrosen9-107.pt\").shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "trebek_2381.pt\n", + "trebek_979.pt\n", + "trebek_1435.pt\n", + "trebek_1015.pt\n", + "trebek_861.pt\n", + "trebek_1024.pt\n", + "trebek_808.pt\n", + "trebek_533.pt\n", + "trebek_2032.pt\n", + "trebek_2075.pt\n", + "trebek_814.pt\n", + "trebek_1795.pt\n", + "trebek_2355.pt\n", + "trebek_759.pt\n", + "trebek_1919.pt\n", + "trebek_2230.pt\n", + "trebek_736.pt\n", + "trebek_137.pt\n", + "trebek_239.pt\n", + "trebek_1983.pt\n", + "trebek_1258.pt\n", + "trebek_1776.pt\n", + "trebek_1917.pt\n", + "trebek_649.pt\n", + "trebek_2153.pt\n", + "trebek_144.pt\n", + "trebek_1231.pt\n", + "trebek_1455.pt\n", + "2450 tries, 28 fails\n" + ] + } + ], + "source": [ + "tries = 0\n", + "fails = 0\n", + "for pt in os.listdir(\"/home/ubuntu/trebek/wavs/\"):\n", + " if not pt.endswith(\".pt\"):# or pt.startswith(\"michaelrosen_\"):\n", + " continue\n", + " try:\n", + " npmel = np.load(f\"/home/ubuntu/hg_tune_data/mels/{pt.replace('pt', 'npy')}\")\n", + " except Exception:\n", + " #print(f\"np version of {pt} probably doesn't exist\")\n", + " continue\n", + " tmel = torch.load(f\"/home/ubuntu/trebek/wavs/{pt}\").unsqueeze(0)\n", + " tries += 1\n", + " if npmel.shape != tmel.shape:\n", + " fails += 1\n", + " print(pt)\n", + " #print(npmel.shape)\n", + " #print(tmel.shape)\n", + "print(f\"{tries} tries, {fails} fails\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(\"422, 26\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Environment (conda_pytorch_p36)", + "language": "python", + "name": "conda_pytorch_p36" + }, + "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.6.10" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From 13c6acb4f8dc4e05f973db3f44ab9deb75a638b2 Mon Sep 17 00:00:00 2001 From: zach wener Date: Thu, 18 Mar 2021 01:18:04 +0000 Subject: [PATCH 11/16] better plotting, tensorboard, better checkpointing --- .../Tacotron2/plotting_utils.py | 44 +++++++++++++++++++ PyTorch/SpeechSynthesis/Tacotron2/train.py | 31 +++++++++++-- 2 files changed, 71 insertions(+), 4 deletions(-) create mode 100644 PyTorch/SpeechSynthesis/Tacotron2/plotting_utils.py diff --git a/PyTorch/SpeechSynthesis/Tacotron2/plotting_utils.py b/PyTorch/SpeechSynthesis/Tacotron2/plotting_utils.py new file mode 100644 index 000000000..0983212c9 --- /dev/null +++ b/PyTorch/SpeechSynthesis/Tacotron2/plotting_utils.py @@ -0,0 +1,44 @@ +import matplotlib +matplotlib.use("Agg") +import matplotlib.pylab as plt +import numpy as np + +def save_figure_to_numpy(fig): + # save it to a numpy array. + data = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8, sep='') + data = data.reshape(fig.canvas.get_width_height()[::-1] + (3,)) + return data + +def plot_alignment_to_numpy(alignment, info=None): + fig, ax = plt.subplots(figsize=(6, 4)) + im = ax.imshow(alignment, aspect='auto', origin='lower', + interpolation='none') + fig.colorbar(im, ax=ax) + xlabel = 'Decoder timestep' + if info is not None: + xlabel += '\n\n' + info + plt.xlabel(xlabel) + plt.ylabel('Encoder timestep') + plt.tight_layout() + + fig.canvas.draw() + data = save_figure_to_numpy(fig) + plt.close() + return data + +def plot_mel_to_numpy(alignment, info=None): + fig, ax = plt.subplots(figsize=(6, 4)) + im = ax.imshow(alignment, aspect='auto', origin='lower', + interpolation='none') + fig.colorbar(im, ax=ax) + xlabel = 'Timestep' + if info is not None: + xlabel += '\n\n' + info + plt.xlabel(xlabel) + plt.ylabel('Frequencies') + plt.tight_layout() + + fig.canvas.draw() + data = save_figure_to_numpy(fig) + plt.close() + return data diff --git a/PyTorch/SpeechSynthesis/Tacotron2/train.py b/PyTorch/SpeechSynthesis/Tacotron2/train.py index 85abee3a6..5037f0b66 100644 --- a/PyTorch/SpeechSynthesis/Tacotron2/train.py +++ b/PyTorch/SpeechSynthesis/Tacotron2/train.py @@ -30,9 +30,9 @@ import argparse import numpy as np from contextlib import contextmanager - import torch from torch.utils.data import DataLoader +from torch.utils.tensorboard import SummaryWriter from torch.autograd import Variable from torch.nn.parameter import Parameter @@ -45,6 +45,7 @@ import loss_functions import data_functions from common.utils import ParseFromConfigFile +from plotting_utils import plot_alignment_to_numpy, plot_mel_to_numpy import dllogger as DLLogger from dllogger import StdOutBackend, JSONStreamBackend, Verbosity @@ -76,6 +77,7 @@ def parse_args(parser): parser.add_argument('--config-file', action=ParseFromConfigFile, type=str, help='Path to configuration file') + parser.add_argument('--tensorboard-path', type=str, default="runs") # training training = parser.add_argument_group('training setup') @@ -231,7 +233,8 @@ def save_checkpoint(model, optimizer, epoch, config, amp_run, output_dir, model_ print("Updating symlink", symlink_dst, "to point to", symlink_src) os.remove(symlink_dst) - os.symlink(symlink_src, symlink_dst) + # os.symlink(symlink_src, symlink_dst) + torch.save(checkpoint, symlink_dst) def get_last_checkpoint_filename(output_dir, model_name): @@ -283,7 +286,8 @@ def evaluating(model): def validate(model, criterion, valset, epoch, batch_iter, batch_size, - world_size, collate_fn, distributed_run, rank, batch_to_gpu): + world_size, collate_fn, distributed_run, rank, batch_to_gpu, + summary_writer=None): """Handles all the validation scoring and printing""" with evaluating(model), torch.no_grad(): val_sampler = DistributedSampler(valset) if distributed_run else None @@ -302,6 +306,20 @@ def validate(model, criterion, valset, epoch, batch_iter, batch_size, x, y, num_items = batch_to_gpu(batch) y_pred = model(x) loss = criterion(y_pred, y) + if i % 50 == 0 and summary_writer is not None: + _, mel_outputs_postnet, _, alignments = y_pred + summary_writer.add_image( + f'attention_weights_sample_{i}', + plot_alignment_to_numpy(alignments[0].data.cpu().numpy().T), + epoch, + dataformats='HWC', + ) + summary_writer.add_image( + f'mel_outputs_sample_{i}', + plot_mel_to_numpy(mel_outputs_postnet[0].data.cpu().numpy()), + epoch, + dataformats='HWC', + ) if distributed_run: reduced_val_loss = reduce_tensor(loss.data, world_size).item() reduced_num_items = reduce_tensor(num_items.data, 1).item() @@ -354,6 +372,8 @@ def main(): parser = parse_args(parser) args, _ = parser.parse_known_args() + writer = SummaryWriter(args.tensorboard_path) + if 'LOCAL_RANK' in os.environ and 'WORLD_SIZE' in os.environ: local_rank = int(os.environ['LOCAL_RANK']) world_size = int(os.environ['WORLD_SIZE']) @@ -499,6 +519,7 @@ def main(): raise Exception("loss is NaN") DLLogger.log(step=(epoch,i), data={'train_loss': reduced_loss}) + writer.add_scalar("train/loss", reduced_loss, num_iters) num_iters += 1 @@ -540,7 +561,8 @@ def main(): iteration, args.batch_size, world_size, collate_fn, distributed_run, local_rank, - batch_to_gpu) + batch_to_gpu, + summary_writer=writer) if (epoch % args.epochs_per_checkpoint == 0) and args.bench_class == "": save_checkpoint(model, optimizer, epoch, model_config, @@ -554,6 +576,7 @@ def main(): run_time = run_stop_time - run_start_time DLLogger.log(step=tuple(), data={'run_time': run_time}) DLLogger.log(step=tuple(), data={'val_loss': val_loss}) + writer.add_scalar("val/loss", val_loss, num_iters) DLLogger.log(step=tuple(), data={'train_items_per_sec': (train_epoch_items_per_sec/num_iters if num_iters > 0 else 0.0)}) DLLogger.log(step=tuple(), data={'val_items_per_sec': val_items_per_sec}) From 9503bf695f90b621536e8687bf664bdb635c937c Mon Sep 17 00:00:00 2001 From: zach wener Date: Thu, 18 Mar 2021 01:46:05 +0000 Subject: [PATCH 12/16] Only init tensorboard on local_rank 0 --- PyTorch/SpeechSynthesis/Tacotron2/train.py | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/PyTorch/SpeechSynthesis/Tacotron2/train.py b/PyTorch/SpeechSynthesis/Tacotron2/train.py index 5037f0b66..ddb691279 100644 --- a/PyTorch/SpeechSynthesis/Tacotron2/train.py +++ b/PyTorch/SpeechSynthesis/Tacotron2/train.py @@ -372,8 +372,6 @@ def main(): parser = parse_args(parser) args, _ = parser.parse_known_args() - writer = SummaryWriter(args.tensorboard_path) - if 'LOCAL_RANK' in os.environ and 'WORLD_SIZE' in os.environ: local_rank = int(os.environ['LOCAL_RANK']) world_size = int(os.environ['WORLD_SIZE']) @@ -381,6 +379,12 @@ def main(): local_rank = args.rank world_size = args.world_size + if local_rank == 0: + writer = SummaryWriter(args.tensorboard_path) + else: + writer = None + + distributed_run = world_size > 1 if local_rank == 0: @@ -519,7 +523,8 @@ def main(): raise Exception("loss is NaN") DLLogger.log(step=(epoch,i), data={'train_loss': reduced_loss}) - writer.add_scalar("train/loss", reduced_loss, num_iters) + if writer: + writer.add_scalar("train/loss", reduced_loss, num_iters) num_iters += 1 @@ -576,7 +581,8 @@ def main(): run_time = run_stop_time - run_start_time DLLogger.log(step=tuple(), data={'run_time': run_time}) DLLogger.log(step=tuple(), data={'val_loss': val_loss}) - writer.add_scalar("val/loss", val_loss, num_iters) + if writer: + writer.add_scalar("val/loss", val_loss, num_iters) DLLogger.log(step=tuple(), data={'train_items_per_sec': (train_epoch_items_per_sec/num_iters if num_iters > 0 else 0.0)}) DLLogger.log(step=tuple(), data={'val_items_per_sec': val_items_per_sec}) From 4400fd53ec3009738292e7f2771752eaeedee086 Mon Sep 17 00:00:00 2001 From: zach wener Date: Thu, 18 Mar 2021 02:10:50 +0000 Subject: [PATCH 13/16] Update --- PyTorch/SpeechSynthesis/Tacotron2/train.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/PyTorch/SpeechSynthesis/Tacotron2/train.py b/PyTorch/SpeechSynthesis/Tacotron2/train.py index ddb691279..96479f3cb 100644 --- a/PyTorch/SpeechSynthesis/Tacotron2/train.py +++ b/PyTorch/SpeechSynthesis/Tacotron2/train.py @@ -524,7 +524,7 @@ def main(): DLLogger.log(step=(epoch,i), data={'train_loss': reduced_loss}) if writer: - writer.add_scalar("train/loss", reduced_loss, num_iters) + writer.add_scalar("train/loss", reduced_loss, iteration) num_iters += 1 @@ -582,7 +582,7 @@ def main(): DLLogger.log(step=tuple(), data={'run_time': run_time}) DLLogger.log(step=tuple(), data={'val_loss': val_loss}) if writer: - writer.add_scalar("val/loss", val_loss, num_iters) + writer.add_scalar("val/loss", val_loss, iteration) DLLogger.log(step=tuple(), data={'train_items_per_sec': (train_epoch_items_per_sec/num_iters if num_iters > 0 else 0.0)}) DLLogger.log(step=tuple(), data={'val_items_per_sec': val_items_per_sec}) From f719d6c86dbada44acf520d45e7828cc9b3fbf45 Mon Sep 17 00:00:00 2001 From: zach wener Date: Thu, 18 Mar 2021 06:24:54 +0000 Subject: [PATCH 14/16] no more symlink --- PyTorch/SpeechSynthesis/Tacotron2/train.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/PyTorch/SpeechSynthesis/Tacotron2/train.py b/PyTorch/SpeechSynthesis/Tacotron2/train.py index 96479f3cb..2f0bf283b 100644 --- a/PyTorch/SpeechSynthesis/Tacotron2/train.py +++ b/PyTorch/SpeechSynthesis/Tacotron2/train.py @@ -240,8 +240,10 @@ def save_checkpoint(model, optimizer, epoch, config, amp_run, output_dir, model_ def get_last_checkpoint_filename(output_dir, model_name): symlink = os.path.join(output_dir, "checkpoint_{}_last.pt".format(model_name)) if os.path.exists(symlink): - print("Loading checkpoint from symlink", symlink) - return os.path.join(output_dir, os.readlink(symlink)) + print("Loading last checkpoint") + return symlink + # print("Loading checkpoint from symlink", symlink) + # return os.path.join(output_dir, os.readlink(symlink)) else: print("No last checkpoint available - starting from epoch 0 ") return "" From 49f34f87f14937b7af34cc8ee25ad0ca048bac4c Mon Sep 17 00:00:00 2001 From: zach wener Date: Fri, 19 Mar 2021 05:26:51 +0000 Subject: [PATCH 15/16] Add val loss and support both checkpoints and resume_from_last --- PyTorch/SpeechSynthesis/Tacotron2/train.py | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/PyTorch/SpeechSynthesis/Tacotron2/train.py b/PyTorch/SpeechSynthesis/Tacotron2/train.py index 2f0bf283b..054d9ce41 100644 --- a/PyTorch/SpeechSynthesis/Tacotron2/train.py +++ b/PyTorch/SpeechSynthesis/Tacotron2/train.py @@ -436,12 +436,13 @@ def main(): start_epoch = [0] - if args.resume_from_last: - args.checkpoint_path = get_last_checkpoint_filename(args.output, model_name) - if args.checkpoint_path is not "": load_checkpoint(model, optimizer, start_epoch, model_config, args.amp, args.checkpoint_path, local_rank) + elif args.resume_from_last: + args.checkpoint_path = get_last_checkpoint_filename(args.output, model_name) + load_checkpoint(model, optimizer, start_epoch, model_config, + args.amp, args.checkpoint_path, local_rank) start_epoch = start_epoch[0] @@ -570,6 +571,8 @@ def main(): distributed_run, local_rank, batch_to_gpu, summary_writer=writer) + if writer: + writer.add_scalar("val/loss", val_loss, iteration) if (epoch % args.epochs_per_checkpoint == 0) and args.bench_class == "": save_checkpoint(model, optimizer, epoch, model_config, From 333ef736c02669f5aed36eb066ab0aa4cf02b4b9 Mon Sep 17 00:00:00 2001 From: Ubuntu Date: Fri, 19 Mar 2021 19:22:14 +0000 Subject: [PATCH 16/16] wip --- PyTorch/SpeechSynthesis/Tacotron2/train.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/PyTorch/SpeechSynthesis/Tacotron2/train.py b/PyTorch/SpeechSynthesis/Tacotron2/train.py index 054d9ce41..bd0264fc2 100644 --- a/PyTorch/SpeechSynthesis/Tacotron2/train.py +++ b/PyTorch/SpeechSynthesis/Tacotron2/train.py @@ -418,6 +418,10 @@ def main(): cpu_run=False, uniform_initialize_bn_weight=not args.disable_uniform_initialize_bn_weight) + if args.freeze_encoder: + for param in model.encoder.parameters(): + param.requires_grad = False + if not args.amp and distributed_run: model = DDP(model) @@ -480,9 +484,6 @@ def main(): num_iters = 0 model.train() - if args.freeze_encoder: - for param in model.encoder.parameters(): - param.requires_grad = False for epoch in range(start_epoch, args.epochs): torch.cuda.synchronize()