{ "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": { "id": "bm4emgbs_ckl" }, "outputs": [], "source": [ "import os\n", "os.environ['CUDA_VISIBLE_DEVICES']='0'\n", "import torch\n", "import math,os,requests, random\n", "from torch import nn\n", "import torch.nn.functional as F\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "from tqdm.notebook import tqdm\n", "import inspect\n", "from torch.cuda.amp import autocast, GradScaler\n", "from time import time" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "id": "vGoI0xQRU-kY" }, "outputs": [], "source": [ "device = torch.device('cuda') if torch.cuda.is_available() else 'cpu'\n", "batch_size = 512\n", "block_size = 256" ] }, { "cell_type": "markdown", "metadata": { "id": "_GdXc1kJneyH" }, "source": [ "## Text input" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "id": "8HSIgCNFE2BB" }, "outputs": [], "source": [ "path = os.path.join('/home/datta0/','cano.txt')\n", "if not os.path.isfile(path):\n", " response = requests.get(\"https://sherlock-holm.es/stories/plain-text/cano.txt\")\n", " if response.status_code == 200:\n", " # Save the content to a local file\n", " with open(path, \"w\", encoding=\"utf-8\") as file:\n", " file.write(response.text)\n", " print(\"File downloaded successfully.\")\n", " else:\n", " print(f\"Failed to download file. Status code: {response.status_code}\")\n", "\n", "with open(path, 'r') as f:\n", " total_text = f.read()\n" ] }, { "cell_type": "markdown", "metadata": { "id": "1evQKNOvnnfd" }, "source": [ "## Process data" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "id": "brkGH7_lHQdF" }, "outputs": [], "source": [ "all_characters = sorted(list(set([x for x in total_text])))\n", "char_to_idx = {char:idx for idx, char in enumerate(all_characters)}\n", "idx_to_char = {idx:char for idx, char in enumerate(all_characters)}" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'\\n': 0,\n", " ' ': 1,\n", " '!': 2,\n", " '\"': 3,\n", " '&': 4,\n", " \"'\": 5,\n", " '(': 6,\n", " ')': 7,\n", " '*': 8,\n", " ',': 9,\n", " '-': 10,\n", " '.': 11,\n", " '0': 12,\n", " '1': 13,\n", " '2': 14,\n", " '3': 15,\n", " '4': 16,\n", " '5': 17,\n", " '6': 18,\n", " '7': 19,\n", " '8': 20,\n", " '9': 21,\n", " ':': 22,\n", " ';': 23,\n", " '?': 24,\n", " 'A': 25,\n", " 'B': 26,\n", " 'C': 27,\n", " 'D': 28,\n", " 'E': 29,\n", " 'F': 30,\n", " 'G': 31,\n", " 'H': 32,\n", " 'I': 33,\n", " 'J': 34,\n", " 'K': 35,\n", " 'L': 36,\n", " 'M': 37,\n", " 'N': 38,\n", " 'O': 39,\n", " 'P': 40,\n", " 'Q': 41,\n", " 'R': 42,\n", " 'S': 43,\n", " 'T': 44,\n", " 'U': 45,\n", " 'V': 46,\n", " 'W': 47,\n", " 'X': 48,\n", " 'Y': 49,\n", " 'Z': 50,\n", " '[': 51,\n", " ']': 52,\n", " '`': 53,\n", " 'a': 54,\n", " 'b': 55,\n", " 'c': 56,\n", " 'd': 57,\n", " 'e': 58,\n", " 'f': 59,\n", " 'g': 60,\n", " 'h': 61,\n", " 'i': 62,\n", " 'j': 63,\n", " 'k': 64,\n", " 'l': 65,\n", " 'm': 66,\n", " 'n': 67,\n", " 'o': 68,\n", " 'p': 69,\n", " 'q': 70,\n", " 'r': 71,\n", " 's': 72,\n", " 't': 73,\n", " 'u': 74,\n", " 'v': 75,\n", " 'w': 76,\n", " 'x': 77,\n", " 'y': 78,\n", " 'z': 79,\n", " '£': 80,\n", " '°': 81,\n", " 'ß': 82,\n", " 'à': 83,\n", " 'â': 84,\n", " 'è': 85,\n", " 'é': 86,\n", " 'ê': 87,\n", " 'î': 88,\n", " 'ñ': 89,\n", " 'ô': 90,\n", " 'ö': 91,\n", " 'û': 92,\n", " 'ü': 93,\n", " '’': 94}" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "char_to_idx" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "id": "BDDriRiOOJof" }, "outputs": [], "source": [ "def encode(text):\n", " return [char_to_idx.get(x) for x in text]\n", "def decode(indices):\n", " return [idx_to_char.get(idx) for idx in indices]\n", "\n", "def batch_encode(batch):\n", " batch_encoded = []\n", " for text in batch:\n", " batch_encoded.append(encode(text))\n", " return batch_encoded\n", "\n", "def batch_decode(batch):\n", " batch_decoded = []\n", " for indices in batch:\n", " batch_decoded.append(decode(indices))\n", " return batch_decoded" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "total_text_len = len(total_text)\n", "\n", "train_len = int(0.9*total_text_len)\n", "encoded_train_text = np.array(encode(total_text[:train_len]))\n", "val_len = total_text_len - train_len\n", "encoded_val_text = np.array(encode(total_text[train_len:]))\n", "\n", "def get_batch(encoded_text, batch_size,total_len):\n", " ix = torch.randint(total_len - block_size, (batch_size,)) # get random starting indices \n", " x = torch.stack([torch.from_numpy((encoded_text[i:i+block_size]).astype(np.int64)) for i in ix])\n", " y = torch.stack([torch.from_numpy((encoded_text[i+1:i+1+block_size]).astype(np.int64)) for i in ix])\n", " x, y = x.pin_memory().to(device, non_blocking=True), y.pin_memory().to(device, non_blocking=True)\n", " return x,y\n", "\n", "def get_data(split,batch_size=512):\n", " if split=='train':\n", " return get_batch(encoded_train_text, batch_size, train_len)\n", " else:\n", " return get_batch(encoded_val_text, batch_size, val_len)" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "((tensor([[65, 65, 1, 66, 58, 1, 73, 61, 54, 73, 1, 72, 61, 58, 1, 62, 72, 0,\n", " 62, 67, 1, 36, 68, 67, 57, 68, 67, 9, 1, 55, 74, 73, 1, 54, 72, 1,\n", " 76, 58, 1, 61, 54, 75, 58, 1, 54, 73, 1, 69, 71, 58, 72, 58, 67, 73,\n", " 1, 67, 68, 1, 69, 68, 72, 72, 62, 55, 65, 58, 1, 66, 58, 54, 67, 72,\n", " 1, 68, 59, 1, 73, 58, 65, 65, 62, 67, 60, 0, 76, 61, 58, 71, 58, 9,\n", " 1, 76, 58, 1, 56, 54, 67, 1, 68, 67, 65, 78, 1, 73, 54, 64, 58, 1,\n", " 73, 61, 58, 1, 68, 55, 75, 62, 68, 74, 72, 1, 72, 73, 58, 69, 72, 9,\n", " 1, 58, 54, 73, 1, 68, 74, 71, 1, 57, 62, 67, 67, 58, 71, 9, 1, 54,\n", " 67, 57, 0, 69, 68, 72, 72, 58, 72, 72, 1, 68, 74, 71, 1, 72, 68, 74,\n", " 65, 72, 1, 62, 67, 1, 69, 54, 73, 62, 58, 67, 56, 58, 11, 1, 36, 54,\n", " 73, 58, 71, 1, 62, 67, 1, 73, 61, 58, 1, 58, 75, 58, 67, 62, 67, 60,\n", " 1, 33, 1, 76, 62, 65, 65, 1, 72, 73, 71, 68, 65, 65, 0, 57, 68, 76,\n", " 67, 1, 54, 67, 57, 1, 61, 54, 75, 58, 1, 54, 1, 76, 68, 71, 57, 1,\n", " 76, 62, 73, 61, 1, 59, 71, 62, 58, 67, 57, 1, 36, 58, 72, 73, 71, 54,\n", " 57, 58, 1, 54]], device='cuda:0'),\n", " tensor([[65, 1, 66, 58, 1, 73, 61, 54, 73, 1, 72, 61, 58, 1, 62, 72, 0, 62,\n", " 67, 1, 36, 68, 67, 57, 68, 67, 9, 1, 55, 74, 73, 1, 54, 72, 1, 76,\n", " 58, 1, 61, 54, 75, 58, 1, 54, 73, 1, 69, 71, 58, 72, 58, 67, 73, 1,\n", " 67, 68, 1, 69, 68, 72, 72, 62, 55, 65, 58, 1, 66, 58, 54, 67, 72, 1,\n", " 68, 59, 1, 73, 58, 65, 65, 62, 67, 60, 0, 76, 61, 58, 71, 58, 9, 1,\n", " 76, 58, 1, 56, 54, 67, 1, 68, 67, 65, 78, 1, 73, 54, 64, 58, 1, 73,\n", " 61, 58, 1, 68, 55, 75, 62, 68, 74, 72, 1, 72, 73, 58, 69, 72, 9, 1,\n", " 58, 54, 73, 1, 68, 74, 71, 1, 57, 62, 67, 67, 58, 71, 9, 1, 54, 67,\n", " 57, 0, 69, 68, 72, 72, 58, 72, 72, 1, 68, 74, 71, 1, 72, 68, 74, 65,\n", " 72, 1, 62, 67, 1, 69, 54, 73, 62, 58, 67, 56, 58, 11, 1, 36, 54, 73,\n", " 58, 71, 1, 62, 67, 1, 73, 61, 58, 1, 58, 75, 58, 67, 62, 67, 60, 1,\n", " 33, 1, 76, 62, 65, 65, 1, 72, 73, 71, 68, 65, 65, 0, 57, 68, 76, 67,\n", " 1, 54, 67, 57, 1, 61, 54, 75, 58, 1, 54, 1, 76, 68, 71, 57, 1, 76,\n", " 62, 73, 61, 1, 59, 71, 62, 58, 67, 57, 1, 36, 58, 72, 73, 71, 54, 57,\n", " 58, 1, 54, 73]], device='cuda:0')),\n", " [['l',\n", " 'l',\n", " ' ',\n", " 'm',\n", " 'e',\n", " ' ',\n", " 't',\n", " 'h',\n", " 'a',\n", " 't',\n", " ' ',\n", " 's',\n", " 'h',\n", " 'e',\n", " ' ',\n", " 'i',\n", " 's',\n", " '\\n',\n", " 'i',\n", " 'n',\n", " ' ',\n", " 'L',\n", " 'o',\n", " 'n',\n", " 'd',\n", " 'o',\n", " 'n',\n", " ',',\n", " ' ',\n", " 'b',\n", " 'u',\n", " 't',\n", " ' ',\n", " 'a',\n", " 's',\n", " ' ',\n", " 'w',\n", " 'e',\n", " ' ',\n", " 'h',\n", " 'a',\n", " 'v',\n", " 'e',\n", " ' ',\n", " 'a',\n", " 't',\n", " ' ',\n", " 'p',\n", " 'r',\n", " 'e',\n", " 's',\n", " 'e',\n", " 'n',\n", " 't',\n", " ' ',\n", " 'n',\n", " 'o',\n", " ' ',\n", " 'p',\n", " 'o',\n", " 's',\n", " 's',\n", " 'i',\n", " 'b',\n", " 'l',\n", " 'e',\n", " ' ',\n", " 'm',\n", " 'e',\n", " 'a',\n", " 'n',\n", " 's',\n", " ' ',\n", " 'o',\n", " 'f',\n", " ' ',\n", " 't',\n", " 'e',\n", " 'l',\n", " 'l',\n", " 'i',\n", " 'n',\n", " 'g',\n", " '\\n',\n", " 'w',\n", " 'h',\n", " 'e',\n", " 'r',\n", " 'e',\n", " ',',\n", " ' ',\n", " 'w',\n", " 'e',\n", " ' ',\n", " 'c',\n", " 'a',\n", " 'n',\n", " ' ',\n", " 'o',\n", " 'n',\n", " 'l',\n", " 'y',\n", " ' ',\n", " 't',\n", " 'a',\n", " 'k',\n", " 'e',\n", " ' ',\n", " 't',\n", " 'h',\n", " 'e',\n", " ' ',\n", " 'o',\n", " 'b',\n", " 'v',\n", " 'i',\n", " 'o',\n", " 'u',\n", " 's',\n", " ' ',\n", " 's',\n", " 't',\n", " 'e',\n", " 'p',\n", " 's',\n", " ',',\n", " ' ',\n", " 'e',\n", " 'a',\n", " 't',\n", " ' ',\n", " 'o',\n", " 'u',\n", " 'r',\n", " ' ',\n", " 'd',\n", " 'i',\n", " 'n',\n", " 'n',\n", " 'e',\n", " 'r',\n", " ',',\n", " ' ',\n", " 'a',\n", " 'n',\n", " 'd',\n", " '\\n',\n", " 'p',\n", " 'o',\n", " 's',\n", " 's',\n", " 'e',\n", " 's',\n", " 's',\n", " ' ',\n", " 'o',\n", " 'u',\n", " 'r',\n", " ' ',\n", " 's',\n", " 'o',\n", " 'u',\n", " 'l',\n", " 's',\n", " ' ',\n", " 'i',\n", " 'n',\n", " ' ',\n", " 'p',\n", " 'a',\n", " 't',\n", " 'i',\n", " 'e',\n", " 'n',\n", " 'c',\n", " 'e',\n", " '.',\n", " ' ',\n", " 'L',\n", " 'a',\n", " 't',\n", " 'e',\n", " 'r',\n", " ' ',\n", " 'i',\n", " 'n',\n", " ' ',\n", " 't',\n", " 'h',\n", " 'e',\n", " ' ',\n", " 'e',\n", " 'v',\n", " 'e',\n", " 'n',\n", " 'i',\n", " 'n',\n", " 'g',\n", " ' ',\n", " 'I',\n", " ' ',\n", " 'w',\n", " 'i',\n", " 'l',\n", " 'l',\n", " ' ',\n", " 's',\n", " 't',\n", " 'r',\n", " 'o',\n", " 'l',\n", " 'l',\n", " '\\n',\n", " 'd',\n", " 'o',\n", " 'w',\n", " 'n',\n", " ' ',\n", " 'a',\n", " 'n',\n", " 'd',\n", " ' ',\n", " 'h',\n", " 'a',\n", " 'v',\n", " 'e',\n", " ' ',\n", " 'a',\n", " ' ',\n", " 'w',\n", " 'o',\n", " 'r',\n", " 'd',\n", " ' ',\n", " 'w',\n", " 'i',\n", " 't',\n", " 'h',\n", " ' ',\n", " 'f',\n", " 'r',\n", " 'i',\n", " 'e',\n", " 'n',\n", " 'd',\n", " ' ',\n", " 'L',\n", " 'e',\n", " 's',\n", " 't',\n", " 'r',\n", " 'a',\n", " 'd',\n", " 'e',\n", " ' ',\n", " 'a']])" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a = get_data('train',1)\n", "b = batch_decode(a[0].tolist())\n", "a,b" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "id": "cklZZJgOb-qa" }, "outputs": [], "source": [ "def repeat_kv(hidden_states, repeat_times):\n", " if repeat_times == 1:\n", " return hidden_states\n", " batch, n_kv_heads, seq_len, head_dim = hidden_states.shape #Shape of q aka Wq@x\n", " hidden_states = hidden_states[:,:,None,:,:].expand(batch, n_kv_heads, repeat_times, seq_len, head_dim) #\n", " return hidden_states.reshape(batch, n_kv_heads*repeat_times, seq_len, head_dim)" ] }, { "cell_type": "markdown", "metadata": { "id": "rqzKT_7lns4W" }, "source": [ "## Model Architecture" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "id": "XTjOd3VztBQz" }, "outputs": [], "source": [ "class RMSNorm(nn.Module):\n", " def __init__(self, hidden_size, eps=1e-6):\n", " super().__init__()\n", " self.weight = nn.Parameter(torch.ones(hidden_size))\n", " self.variance_epsilon = eps\n", "\n", " def forward(self, hidden_states):\n", " input_dtype = hidden_states.dtype\n", " hidden_states = hidden_states.to(torch.float32)\n", " variance = hidden_states.pow(2).mean(-1, keepdim=True)\n", " hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon)\n", " return self.weight * hidden_states.to(input_dtype)\n", "\n", "class PositionalEncoding(nn.Module):\n", " def __init__(self, hidden_size, max_seq_len):\n", " super().__init__()\n", " self.encoding = torch.zeros(max_seq_len, hidden_size)\n", " position = torch.arange(0, max_seq_len, dtype=torch.float).unsqueeze(1)\n", " div_term = torch.exp(torch.arange(0, hidden_size, 2).float() * (-math.log(10000.0) / hidden_size))\n", " self.encoding[:, 0::2] = torch.sin(position * div_term)\n", " self.encoding[:, 1::2] = torch.cos(position * div_term)\n", " self.encoding = self.encoding.unsqueeze(0)\n", "\n", " def forward(self, x):\n", " if self.encoding.device != x.device:\n", " self.encoding = self.encoding.to(x.device)\n", " return x + self.encoding[:, :x.size(1)].detach()" ] }, { "attachments": { "image.png": { "image/png": "iVBORw0KGgoAAAANSUhEUgAABHAAAAPYCAYAAACyng7XAAAMQWlDQ1BJQ0MgUHJvZmlsZQAASImVVwdYU8kWnluSkJDQAghICb0JIlICSAmhhd4RRCUkAUKJMRBU7OiigmsXC9jQVREFKyAWFLGzKPa+WFBQ1sWCXXmTArruK9+b75s7//3nzH/OnDtz7x0A1E9wxeJcVAOAPFGBJDbYnzE2OYVB6gYEoAuogAEoXF6+mBUdHQ5gGWz/Xt7dAIisveog0/pn/38tmnxBPg8AJBridH4+Lw/igwDglTyxpAAAoow3n1IglmFYgbYEBgjxQhnOVOBKGU5X4L1ym/hYNsStAKhQuVxJJgBqlyHPKORlQg21PoidRHyhCAB1BsQ+eXmT+BCnQWwDbcQQy/SZ6T/oZP5NM31Ik8vNHMKKuciLSoAwX5zLnfZ/puN/l7xc6aAPK1ipWZKQWNmcYd5u5UwKk2EqxL2i9MgoiLUg/iDky+0hRilZ0pAEhT1qyMtnw5zBJw1QJz43IAxiQ4iDRLmR4Uo+PUMYxIEYrhB0qrCAEw+xHsQLBfmBcUqbzZJJsUpfaH2GhM1S8ue4Erlfma8H0pwEllL/dZaAo9TH1Iqy4pMgpkBsUShMjIRYDWLH/Jy4MKXNmKIsduSgjUQaK4vfAuJYgSjYX6GPFWZIgmKV9qV5+YPzxTZnCTmRSry/ICs+RJEfrJXHlccP54JdFohYCYM6gvyx4YNz4QsCAhVzx7oFooQ4pc4HcYF/rGIsThHnRivtcTNBbrCMN4PYJb8wTjkWTyyAC1Khj2eIC6LjFXHiRdnc0GhFPPgyEA7YIADuOCms6WASyAbC9t6GXnin6AkCXCABmUAAHJTM4IgkeY8IXuNAEfgTIgHIHxrnL+8VgELIfx1iFVcHkCHvLZSPyAFPIc4DYSAX3kvlo0RD3hLBE8gI/+GdCysPxpsLq6z/3/OD7HeGBZlwJSMd9MhQH7QkBhIDiCHEIKItboD74F54OLz6weqMM3GPwXl8tyc8JXQQHhGuEzoJtycKiyU/RRkBOqF+kDIX6T/mAreCmq64P+4N1aEyrosbAAfcBfph4b7Qsytk2cq4ZVlh/KT9txn88DSUdmQnMkoeRvYj2/w8Us1OzXVIRZbrH/OjiDV9KN/soZ6f/bN/yD4ftmE/W2ILsQPYWewkdh47ijUABtaMNWJt2DEZHlpdT+Sra9BbrDyeHKgj/Ie/wScry2S+U41Tj9MXRV+BYKrsHQ3Yk8TTJMLMrAIGC34RBAyOiOc4guHs5OwCgOz7onh9vYmRfzcQ3bbv3Lw/APBuHhgYOPKdC20GYJ873P6Hv3M2TPjpUAXg3GGeVFKo4HDZhQDfEupwp+kDY2AObOB8nIEb8AJ+IBCEgigQD5LBBBh9FlznEjAFzABzQQkoA8vAarAebAJbwU6wB+wHDeAoOAnOgIvgMrgO7sLV0wVegD7wDnxGEISE0BA6oo+YIJaIPeKMMBEfJBAJR2KRZCQNyUREiBSZgcxDypAVyHpkC1KN7EMOIyeR80gHcht5iPQgr5FPKIZSUW3UCLVCR6JMlIWGofHoeDQTnYwWofPRJehatArdjdajJ9GL6HW0E32B9mMAU8V0MVPMAWNibCwKS8EyMAk2CyvFyrEqrBZrgs/5KtaJ9WIfcSJOxxm4A1zBIXgCzsMn47Pwxfh6fCdej7fiV/GHeB/+jUAjGBLsCZ4EDmEsIZMwhVBCKCdsJxwinIZ7qYvwjkgk6hKtie5wLyYTs4nTiYuJG4h1xBPEDuJjYj+JRNIn2ZO8SVEkLqmAVEJaR9pNaiZdIXWRPqioqpioOKsEqaSoiFSKVcpVdqkcV7mi8kzlM1mDbEn2JEeR+eRp5KXkbeQm8iVyF/kzRZNiTfGmxFOyKXMpaym1lNOUe5Q3qqqqZqoeqjGqQtU5qmtV96qeU32o+pGqRbWjsqmpVCl1CXUH9QT1NvUNjUazovnRUmgFtCW0atop2gPaBzW6mqMaR42vNlutQq1e7YraS3WyuqU6S32CepF6ufoB9UvqvRpkDSsNtgZXY5ZGhcZhjZsa/Zp0zVGaUZp5mos1d2me1+zWImlZaQVq8bXma23VOqX1mI7RzelsOo8+j76NfprepU3UttbmaGdrl2nv0W7X7tPR0nHRSdSZqlOhc0ynUxfTtdLl6ObqLtXdr3tD99Mwo2GsYYJhi4bVDrsy7L3ecD0/PYFeqV6d3nW9T/oM/UD9HP3l+g369w1wAzuDGIMpBhsNThv0Dtce7jWcN7x0+P7hdwxRQzvDWMPphlsN2wz7jYyNgo3ERuuMThn1Gusa+xlnG68yPm7cY0I38TERmqwyaTZ5ztBhsBi5jLWMVkafqaFpiKnUdItpu+lnM2uzBLNiszqz++YUc6Z5hvkq8xbzPgsTiwiLGRY1FncsyZZMyyzLNZZnLd9bWVslWS2warDqttaz5lgXWddY37Oh2fjaTLapsrlmS7Rl2ubYbrC9bIfaudpl2VXYXbJH7d3shfYb7DtGEEZ4jBCNqBpx04HqwHIodKhxeOio6xjuWOzY4PhypMXIlJHLR54d+c3J1SnXaZvT3VFao0JHFY9qGvXa2c6Z51zhfG00bXTQ6NmjG0e/crF3EbhsdLnlSneNcF3g2uL61c3dTeJW69bjbuGe5l7pfpOpzYxmLmae8yB4+HvM9jjq8dHTzbPAc7/nX14OXjleu7y6x1iPEYzZNuaxt5k313uLd6cPwyfNZ7NPp6+pL9e3yveRn7kf32+73zOWLSubtZv10t/JX+J/yP8925M9k30iAAsIDigNaA/UCkwIXB/4IMgsKDOoJqgv2DV4evCJEEJIWMjykJscIw6PU83pC3UPnRnaGkYNiwtbH/Yo3C5cEt4UgUaERqyMuBdpGSmKbIgCUZyolVH3o62jJ0cfiSHGRMdUxDyNHRU7I/ZsHD1uYtyuuHfx/vFL4+8m2CRIE1oS1RNTE6sT3ycFJK1I6hw7cuzMsReTDZKFyY0ppJTElO0p/eMCx60e15XqmlqSemO89fip489PMJiQO+HYRPWJ3IkH0ghpSWm70r5wo7hV3P50Tnpleh+PzVvDe8H346/i9wi8BSsEzzK8M1ZkdGd6Z67M7MnyzSrP6hWyheuFr7JDsjdlv8+JytmRM5CblFuXp5KXlndYpCXKEbVOMp40dVKH2F5cIu6c7Dl59eQ+SZhkez6SPz6/sUAb/si3SW2kv0gfFvoUVhR+mJI45cBUzamiqW3T7KYtmvasKKjot+n4dN70lhmmM+bOeDiTNXPLLGRW+qyW2eaz58/umhM8Z+dcytycub8XOxWvKH47L2le03yj+XPmP/4l+JeaErUSScnNBV4LNi3EFwoXti8avWjdom+l/NILZU5l5WVfFvMWX/h11K9rfx1YkrGkfanb0o3LiMtEy24s912+c4XmiqIVj1dGrKxfxVhVuurt6omrz5e7lG9aQ1kjXdO5Nnxt4zqLdcvWfVmftf56hX9FXaVh5aLK9xv4G65s9NtYu8loU9mmT5uFm29tCd5SX2VVVb6VuLVw69NtidvO/sb8rXq7wfay7V93iHZ07ozd2VrtXl29y3DX0hq0RlrTszt19+U9AXsaax1qt9Tp1pXtBXule5/vS9t3Y3/Y/pYDzAO1By0PVh6iHyqtR+qn1fc1ZDV0NiY3dhwOPdzS5NV06IjjkR1HTY9WHNM5tvQ45fj84wPNRc39J8Qnek9mnnzcMrHl7qmxp661xrS2nw47fe5M0JlTZ1lnm895nzt63vP84QvMCw0X3S7Wt7m2Hfrd9fdD7W7t9ZfcLzVe9rjc1DGm4/gV3ysnrwZcPXONc+3i9cjrHTcSbty6mXqz8xb/Vvft3Nuv7hTe+Xx3zj3CvdL7GvfLHxg+qPrD9o+6TrfOYw8DHrY9int09zHv8Ysn+U++dM1/Snta/szkWXW3c/fRnqCey8/HPe96IX7xubfkT80/K1/avDz4l99fbX1j+7peSV4NvF78Rv/Njrcub1v6o/sfvMt79/l96Qf9Dzs/Mj+e/ZT06dnnKV9IX9Z+tf3a9C3s272BvIEBMVfClf8KYLCiGRkAvN4BAC0ZADo8n1HGKc5/8oIozqxyBP4TVpwR5cUNgFr4/x7TC/9ubgKwdxs8fkF99VQAomkAxHsAdPTooTp4VpOfK2WFCM8Bm6O+puelg39TFGfOH+L+uQUyVRfwc/svfmd8XCh3EmYAAACKZVhJZk1NACoAAAAIAAQBGgAFAAAAAQAAAD4BGwAFAAAAAQAAAEYBKAADAAAAAQACAACHaQAEAAAAAQAAAE4AAAAAAAAAkAAAAAEAAACQAAAAAQADkoYABwAAABIAAAB4oAIABAAAAAEAAARwoAMABAAAAAEAAAPYAAAAAEFTQ0lJAAAAU2NyZWVuc2hvdIYjHIcAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAHXaVRYdFhNTDpjb20uYWRvYmUueG1wAAAAAAA8eDp4bXBtZXRhIHhtbG5zOng9ImFkb2JlOm5zOm1ldGEvIiB4OnhtcHRrPSJYTVAgQ29yZSA2LjAuMCI+CiAgIDxyZGY6UkRGIHhtbG5zOnJkZj0iaHR0cDovL3d3dy53My5vcmcvMTk5OS8wMi8yMi1yZGYtc3ludGF4LW5zIyI+CiAgICAgIDxyZGY6RGVzY3JpcHRpb24gcmRmOmFib3V0PSIiCiAgICAgICAgICAgIHhtbG5zOmV4aWY9Imh0dHA6Ly9ucy5hZG9iZS5jb20vZXhpZi8xLjAvIj4KICAgICAgICAgPGV4aWY6UGl4ZWxZRGltZW5zaW9uPjk4NDwvZXhpZjpQaXhlbFlEaW1lbnNpb24+CiAgICAgICAgIDxleGlmOlBpeGVsWERpbWVuc2lvbj4xMTM2PC9leGlmOlBpeGVsWERpbWVuc2lvbj4KICAgICAgICAgPGV4aWY6VXNlckNvbW1lbnQ+U2NyZWVuc2hvdDwvZXhpZjpVc2VyQ29tbWVudD4KICAgICAgPC9yZGY6RGVzY3JpcHRpb24+CiAgIDwvcmRmOlJERj4KPC94OnhtcG1ldGE+Cse/hNAAAAAcaURPVAAAAAIAAAAAAAAB7AAAACgAAAHsAAAB7AAAgxMJhp+vAABAAElEQVR4AezdC5xt9fz/8e+ppFJkVCjyKCL94pyJcvnHccml3FMSxUQkxRkllSSEon40PyLXGUIp1x+KXA+5JmeGRD+X6iQlqSjpxvn3/uqzrdmzZ++19l6X7/p+X+vxOGdm9l6X7/f5XbP2Wu/5ru9aMjY2tsYxIYAAAggggAACCCCAAAIIIIAAAggEK7CEACfYtqFgCCCAAAIIIIAAAggggAACCCCAgBcgwGFHQAABBBBAAAEEEEAAAQQQQAABBAIXIMAJvIEoHgIIIIAAAggggAACCCCAAAIIIECAwz6AAAIIIIAAAggggAACCCCAAAIIBC5AgBN4A1E8BBBAAAEEEEAAAQQQQAABBBBAgACHfQABBBBAAAEEEEAAAQQQQAABBBAIXIAAJ/AGongIIIAAAggggAACCCCAAAIIIIAAAQ77AAIIIIAAAggggAACCCCAAAIIIBC4AAFO4A1E8RBAAAEEEEAAAQQQQAABBBBAAAECHPYBBBBAAAEEEEAAAQQQQAABBBBAIHABApzAG4jiIYAAAggggAACCCCAAAIIIIAAAgQ47AMIIIAAAggggAACCCCAAAIIIIBA4AIEOIE3EMVDAAEEEEAAAQQQQAABBBBAAAEECHDYBxBAAAEEEEAAAQQQQAABBBBAAIHABQhwAm8giocAAggggAACCCCAAAIIIIAAAggQ4LAPIIAAAggggAACCCCAAAIIIIAAAoELEOAE3kAUDwEEEEAAAQQQQAABBBBAAAEEECDAYR9AAAEEEEAAAQQQQAABBBBAAAEEAhcgwAm8gSgeAggggAACCCCAAAIIIIAAAgggQIDDPoAAAggggAACCCCAAAIIIIAAAggELkCAE3gDUTwEEEAAAQQQQAABBBBAAAEEEECAAId9AAEEEEAAAQQQQAABBBBAAAEEEAhcgAAn8AaieAgggAACCCCAAAIIIIAAAggggAABDvsAAggggAACCCCAAAIIIIAAAgggELgAAU7gDUTxEEAAAQQQQAABBBBAAAEEEEAAAQIc9gEEEEAAAQQQQAABBBBAAAEEEEAgcAECnMAbiOIhgAACCCCAAAIIIIAAAggggAACBDjsAwgggAACCCCAAAIIIIAAAggggEDgAgQ4gTcQxUMAAQQQQAABBBBAAAEEEEAAAQQIcNgHEEAAAQQQQAABBBBAAAEEEEAAgcAFCHACbyCKhwACCCCAAAIIIIAAAggggAACCBDgsA8ggAACCCCAAAIIIIAAAggggAACgQsQ4ATeQBQPAQQQQAABBBBAAAEEEEAAAQQQIMBhH0AAAQQQQAABBBBAAAEEEEAAAQQCFyDACbyBKB4CCCCAQLkCS5YscZtvvrnbZptt3F3vele3evVqd8kll7jrrruu3A2xNgQQQAABBBBAAAEEShQgwCkRk1UhgAACCIQroOBm3333dS94wQvc+uuvv6Cgf/7zn91xxx3nzj///AXvFXlhvfXWc+uuu6678cYb3W233VZk0aHn3XDDDd1aa63lrr/+erdmzZqh18OCCCCAAAIIIIAAAuEKEOCE2zaUDAEEEECgJIE73elO7tBDD3W77rqrX6N621xwwQVOoc1WW23lli1b1tnSKaec4k4//fShg5A3vOEN7klPepI7/vjj3dlnn91Zb5XffPWrX/WhlMKpyy+/vMpNsW4EEEAAAQQQQACBhgQIcBqCZ7MIIIAAAvUJHHHEEZ3w5hOf+ISbnp6e1ztmk002cUcddZTbYYcdfKHe/va3u6997WtDFZAAZyg2FkIAAQQQQAABBBAYIECAMwCItxFAAAEE2i2wxRZbuE996lO+Eh/60IecApxek25Bev/73++23XZbd8UVV7gXvvCF7p///KdT7x39u+WWW+aFPlqHbpVaZ5113M033+zn3WCDDdzhhx/uHve4x7mTTjrJh0C6lUq3b+mfbm/SP61P27npppvcxRdfvGC9ug1L5dH7//rXv+YVV7d/aV1a79prr+3ufOc7u8997nO+B87+++/vLrvsMr/cvIX4AQEEEEAAAQQQQKD1AgQ4rW9CKoAAAggg0E9gxYoVbvfdd/eDFO+11159w42HPOQh7r3vfa9f3SGHHOLHw3nFK17h9t57b/eRj3zEffzjH5+3qaOPPtrtsssu7s1vfrO/JevMM8+c975+2HPPPd2OO+7oXve61zm9r8DnOc95Tme+f/zjH+4tb3mL+8EPftB57cMf/rAfZPnVr361m5ub67yub+x2qec+97n+1i+VITvptrA99tgj+xLfI4AAAggggAACCEQgQIATQSNSBQQQQACBxQU+8IEP+N4u6oWj7wdNX/ziF93GG2/s3vWudzl9nyfAUQBz3nnnuYMOOsg97GEPc5tuuqn79a9/7Z9udfLJJ7vHPvax7rDDDutsWu/pn+a9733v61+3wEg/WICj8Gl2draznL6xAEchjbbzrGc9yz31qU/185x77rnuD3/4g+9JNG8hfkAAAQQQQAABBBBovQABTuubkAoggAACCPQTsMDjhBNOcF/+8pf7zerfm5qa8j1bTjvtNKcBjfMGON/85jf98r3GwHn605/eCXCyQZJuhXrrW9/qdt55Z3fppZe6iYkJf8tU3gBHvW00WR0ZxNhz8B8CCCCAAAIIIBClAAFOlM1KpRBAAAEEJKDxYc455xyPoVuYfvzjHw+EUaDymMc8xn3hC19w7373u0sNcHS71DOe8Qx36623dsqhAZQ/+9nP+p91W9TVV1+duwcOAU6HkW8QQAABBBBAAIHoBQhwom9iKogAAgikLWC9U972trd1wpx+Itb75X3ve5/79Kc/XWqAo9uhdFtU92RlPPjgg90vfvELApxuIH5GAAEEEEAAAQQQcAQ47AQIIIAAAlELaAya7bff3j86fGZmpm9dsz12dCvU9773vb4BznHHHece/ehH+0GI89xC9aUvfcmdeOKJC8pg4/RYLyELkbrHwNEtV9/5znf88hoDhx44Cyh5AQEEEEAAAQQQiFaAACfapqViCCCAAAISeO1rX+tvW1LYoadQ6dHgi0277rqrO+KII/zbz3/+8/3jxPuNgXP66ae7e9/73rkDHIUvxxxzzILNf+Yzn/EDEu+zzz7+MeCLBTjZ260IcBYw8gICCCCAAAIIIBC1AAFO1M1L5RBAAAEE7n//+7uPfvSjHsKeLNVLZcMNN/SDFuupUGeddZZ7xzve4Wfbf//93b777usfAW6PGNcb6623nvva177m59FTqPL0wLniiiucgqHstPnmmzsNmKzpiU98orvtttv8U6S22247Z72AbH49tUp10ESAYyp8RQABBBBAAAEE0hAgwEmjnaklAgggkLTAUUcd5Z785Cd7A4U5p556qn/ak6GoZ8s73/lOp7BHU/ZpTgpV3vjGN/qeMQpzbrrpJj/P4Ycf7nbbbTf/fTbAsW0p7DnzzDP9+9mnUGVDpLXXXtsdffTR7vGPf7z76U9/6g499FA/vx4prseDZ4MkBUYf/OAH3f3udz8/TzbAsUefv/zlL3cXXXSRf5//EEAAAQQQQAABBOISIMCJqz2pDQIIIIBAD4GNN97YKVjZaaedOu9ecMEFfgyZrbfeuhOKXHfdde7II490F154YWe+LbbYwunR35r0qO9f/epX7r/+67+ceurYlA1w1MPmwAMPdHri1Lnnnuv0WPLly5d3HiOuZX70ox+53//+926HHXZw2267rV/N3nvv7f74xz/67xU2qbyaFOxcf/31bnx83KkeNmUDHIVPj3jEI3zIpG3q8edMCCCAAAIIIIAAAnEJEODE1Z7UBgEEEEBgEYG11lrLPe95z3MTExNu/fXXXzCXHjGuIESP8e6eHvvYx7pjjz123stnnHGGW7NmjR9XR+Pa2ODC97nPffxTpGwbe+65pw+ODjvsMPfd737XbbDBBu7hD394Z10KjY4//nj3wx/+sPOaBitWbxr1BLJJgZDCoGc/+9k+9LFHjut9DaSsXkLapsb6UbjDhAACCCCAAAIIIBCXAAFOXO1JbRBAAAEEBggoHLnnPe/pttpqKx94XHLJJb5nTb/BjbVK3e605ZZb+rFv1FPmr3/966JbWmedddxmm23mbr75ZveXv/zF2S1UutVJt1CpJ82DH/xgvw71xLHbsrpXqNum1NNHZV69evWi82k5hTdjY2Pub3/7m++x070ufkYAAQQQQAABBBBotwABTrvbj9IjgAACCLRAoDvAaUGRKSICCCCAAAIIIIBAYAIEOIE1CMVBAAEEEIhPgAAnvjalRggggAACCCCAQN0CBDh1i7M9BBBAAIHkBAhwkmtyKowAAggggAACCJQuQIBTOikrRAABBBBAYL7Apptu6vS0q6uuuspdfPHF89/kJwQQQAABBBBAAAEEcggQ4ORAYhYEEEAAAQQQQAABBBBAAAEEEECgSQECnCb12TYCCCCAAAIIIIAAAggggAACCCCQQ4AAJwcSsyCAAAIIIIAAAggggAACCCCAAAJNChDgNKnPthFAAAEEEEAAAQQQQAABBBBAAIEcAgQ4OZCYBQEEEEAAAQQQQAABBBBAAAEEEGhSgACnSX22jQACCCCAAAIIIIAAAggggAACCOQQIMDJgcQsCCCAAAIIIIAAAggggAACCCCAQJMCBDhN6rNtBBBAAIFoBJYtW+ampqbcihUr3OzsbDT1oiIIIIAAAggggAACYQgQ4ITRDpQCAQQQQKDlAhbgrFq1ys3Nzbnp6emW14jiI4AAAggggAACCIQkQIATUmtQFgQQQACB1gpYgGMVoCeOSfAVAQQQQAABBBBAoAwBApwyFFkHAggggEDyAt0BjnriTE5OJu8CAAIIIIAAAggggEA5AgQ45TiyFgQQQACBxAW6AxxxLF++PHEVqo8AAggggAACCCBQlgABTlmSrAcBBBBAIGmB/fbbz01MTMwz4DaqeRz8gAACCCCAAAIIIDCCAAHOCHgsigACCCCAgAmsXLnSvu185TaqDgXfIIAAAggggAACCIwoQIAzIiCLI4AAAggg0N37RsGNpvHxcR4rzu6BAAIIIIAAAgggUIoAAU4pjKwEAQQQQCBlgX4BDr1wUt4zqDsCCCCAAAIIIFCeAAFOeZasCQEEEEAgUYHu26cU2szMzLipqSkvwmDGie4YVBsBBBBAAAEEEChRgACnRExWhQACCCCQnkB37xsJWK+bk046iduo0tslqDECCCCAAAIIIFCJAAFOJaysFAEEEEAgFQHrfaPQRmPeaLIAxx4tbj+nYkI9EUAAAQQQQAABBMoXIMAp35Q1IoAAAggkIpDtfaNHhtstU9nAxgIebqNKZKegmggggAACCCCAQEUCBDgVwbJaBBBAAIH4BSzA0Xg3Cm16BTjcRhX/fkANEUAAAQQQQACBOgQIcOpQZhsIIIAAAlEKWO+a7gBHP09PT/s6cxtVlE1PpRBAAAEEEEAAgdoFCHBqJ2eDCCCAAAIxCFjvG9VFt0dZUKOfswGOflYvHE2Tk5P+K/8hgAACCCCAAAIIIFBUgACnqBjzI4AAAgggcLuABTgW1vQLcGzefffd161evRo/BBBAAAEEEEAAAQQKCxDgFCZjAQQQQAABBJyz26dscOJ+AY69R4DDnoMAAggggAACCCAwrAABzrByLIcAAgggkKyABTLW+0YQ9pq+z76unzXpNqrzzjvPffKTn/z3C/yPAAIIIIAAAggggEABAQKcAljMigACCCCAgAkosJmdnbUfBwY4mnHLLbfkFqqOGN8ggAACCCCAAAIIFBEgwCmixbwIIIAAAggsIjCoB84ii/EyAggggAACCCCAAAK5BAhwcjExEwIIIIAAAv0FCHD6+/AuAggggAACCCCAwGgCBDij+bE0AggggAACXoAAhx0BAQQQQAABBBBAoEoBApwqdVk3AggggEAyAgQ4yTQ1FUUAAQQQQAABBBoRIMBphJ2NIoAAAgjEJkCAE1uLUh8EEEAAAQQQQCAsAQKcsNqD0iCAAAIItFSAAKelDUexEUAAAQQQQACBlggQ4LSkoSgmAggggEDYAgQ4YbcPpUMAAQQQQAABBNouQIDT9hak/AgggAACQQgQ4ATRDBQCAQQQQAABBBCIVoAAJ9qmpWIIIIAAAnUKEODUqc22EEAAAQQQQACB9AQIcNJrc2qMAAIIIFCBAAFOBaisEgEEEEAAAQQQQKAjQIDToeAbBBBAAAEEhhcgwBnejiURQAABBBBAAAEEBgsQ4Aw2Yg4EEEAAAQQGChDgDCRiBgQQQAABBBBAAIERBAhwRsBjUQQQQAABBEyAAMck+IoAAggggAACCCBQhQABThWqrBMBBBBAIDkBApzkmpwKI4AAAggggAACtQoQ4NTKzcYQQAABBGIVIMCJtWWpFwIIIIAAAgggEIYAAU4Y7UApEEAAAQRaLkCA0/IGpPgIIIAAAggggEDgAgQ4gTcQxUMAAQQQaIcAAU472olSIoAAAggggAACbRUgwGlry1FuBBBAAIGgBAhwgmoOCoMAAggggAACCEQnQIATXZNSIQQQQACBJgQIcJpQZ5sIIIAAAggggEA6AgQ46bQ1NUUAAQQQqFhg5cqVfgszMzNuenq64q2xegQQQAABBBBAAIGUBAhwUmpt6ooAAgggUKkAAU6lvKwcAQQQQAABBBBIWoAAJ+nmp/IIIIAAAmUKEOCUqcm6EEAAAQQQQAABBLICBDhZDb5HAAEEEEBgBAELcFasWOFmZ2dHWBOLIoAAAggggAACCCAwX4AAZ74HPyGAAAIIIDC0AAHO0HQsiAACCCCAAAIIIDBAgABnABBvI4AAAgggkFeAACevFPMhgAACCCCAAAIIFBUgwCkqxvwIIIAAAggsIkCAswgMLyOAAAIIIIAAAgiMLECAMzIhK0AAAQQQQODfAgQ47AkIIIAAAggggAACVQkQ4FQly3oRQAABBJITIMBJrsmpMAIIIIAAAgggUJsAAU5t1GwIAQQQQCB2AQKc2FuY+iGAAAIIIIAAAs0JEOA0Z8+WEUAAAQQiEyDAiaxBqQ4CCCCAAAIIIBCQAAFOQI1BURBAAAEE2i1AgNPu9qP0CCCAAAIIIIBAyAIEOCG3DmVDAAEEEGiVAAFOq5qLwiKAAAIIIIAAAq0SIMBpVXNRWAQQQACBkAUIcEJuHcqGAAIIIIAAAgi0W4AAp93tR+kRQAABBAISIMAJqDEoCgIIIIAAAgggEJkAAU5kDUp1EEAAAQSaEyDAac6eLSOAAAIIIIAAArELEODE3sLUDwEEEECgNgECnNqo2RACCCCAAAIIIJCcAAFOck1OhRFAAAEEqhIgwKlKlvUigAACCCCAAAIIEOCwDyCAAAIIIFCSQJUBziabbOKuvvrqkkrKahBAAAEEEEAAAQTaJkCA07YWo7wIIIAAAsEKVBngLFu2zM3OzgZbdwqGAAIIIIAAAgggUK0AAU61vqwdAQQQQCAhgTIDHAU2miYmJtz4+Lj/fmZmxk1PT/vv+Q8BBBBAAAEEEEAgLQECnLTam9oigAACCFQoMGqA0yu0UXFXrVrlFN7QA6fCxmPVCCCAAAIIIIBA4AIEOIE3EMVDAAEEEGiPwLABjoKbbE8b1ZjQpj3tTkkRQAABBBBAAIE6BAhw6lBmGwgggAACSQgUCXD6hTbCordNErsMlUQAAQQQQAABBHILEODkpmJGBBBAAAEE+gsMCnB6hTZaI71t+rvyLgIIIIAAAggggIBzBDjsBQgggAACCJQksFiAs1hwo3FtFN7kneiVk1eK+RBAAAEEEEAAgfgECHDia1NqhAACCCDQkECvAEfhzdTUVEMl6r/ZIuFR/zU5Nzc3N2iWQu+XWTaCr0L0zIwAAggggAACgQoQ4ATaMBQLAQQQQKB9AieddJJ/5PeKFSvmjWGz3377+UGK21cjStwtUGawVGboVWa5CLy6W52fEUAAAQQQCEOAACeMdqAUCCCAAAIRCCwW4Khq6omjaXx83C1dutR/9S/c8Z9upyo6aT1lTCoTEwJVCJQVLIUYdhF0VbHHsE4EEEAAgX4CBDj9dHgPAQQQQACBAgIW4CxfvjzXUt09cyzEmZ6ezrV8qDNZWDVq+aoIlsoKvVS3Kso3qhnLt1OAoKud7UapEUAAgboFCHDqFmd7CCCAAALRChQNcAxCQY6miYkJ/1X/Kcxpe5DTqQzfDBQoK/SyDZUdLpUZfKmMZZfP6s3XuAUIuuJuX2qHAAKDBQhwBhsxBwIIIIAAArkEhg1wsiuPtVdOto58j0DZAmUGYFWESwRgZbc461tMINaQi1sWF2txXk9NgAAntRanvggggAAClQmUEeBY4XRBqgvJbK+cvLdm2Tr4igACCOQRKDMA0/YIwfKoM09TAmWEXKGNy0XA1dTeVP92CXDqN2eLCCCAAAKRCpQZ4GSJ7BYrbqnKqvA9AgggEI4AIVg4bUFJhhcIKdwatiyxh1kEOMPv3yyJAAIIIIDAPIGqApx5G+EHBBBAAAEEIhUoMwiroieY2LklMuydT8GPxhGMNcghwAl7/6N0CCCAAAItEiDAaVFjUVQEEEAAAQQiFCgzBBNPFUFY1SFYzA+CIMCJ8JeWKiGAAAIINCNAgNOMO1tFAAEEEEAAAQRSECDASaGVqSMCCCCAQC0CBDi1MLMRBBBAAAEEEEAgSQECnCSbnUojgAACCFQhQIBThSrrRAABBBBAAAEEEJAAAQ77AQIIIIAAAiUJEOCUBMlqEEAAAQQQQAABBBYIEOAsIOEFBBBAAAEEhhMgwBnOjaUQQAABBBBAAAEEBgsQ4Aw2Yg4EEEAAAQRyCRDg5GJiJgQQQAABBBBAAIEhBAhwhkBjEQQQQAABBHoJEOD0UuE1BBBAAAEEEEAAgTIECHDKUGQdCCCAAAII3C5AgMNugAACCCCAAAIIIFCVAAFOVbKsFwEEEEAgOQECnOSanAojgAACCCCAAAK1CRDg1EbNhhBAAAEEYhcgwIm9hakfAggggAACCCDQnAABTnP2bBkBBBBAIDIBApzIGpTqIIAAAggggEArBJYtW+ZmZ2dbUdZRCkmAM4oeyyKAAAIIIJARIMDJYPAtAggggAACCCBQk8DKlSvdihUrog9xCHBq2qHYDAIIIIBA/AIEOPG3MTVEAAEEEEAAgbAE9ttvPzcxMeFmZmbc9PR0WIUruTQEOCWDsjoEEEAAgXQFCHDSbXtqjgACCCCAAALNCFiAs2rVKjc5OdlMIWraKgFOTdBsBgEEEEAgfgECnPjbmBoigAACCCCAQFgCun1KEwFOWO1CaRBAAAEEEAhagAAn6OahcAgggAACCCAQmYD1vrFqxT4ODj1wrKX5igACCCCAwIgCBDgjArI4AggggAACCCBQQMB639gisffCIcCxluYrAggggAACIwoQ4IwIyOIIIIAAAggggEBOAT06fGpqyt86NT4+3llq+fLlne9j+4YAJ7YWpT4IIIAAAo0JWDfemE8cGsNlwwgggAACCCCAQEbAzrv09Ck9hcqmmG+jIsCxVuYrAggggAACIwrYiQQBzoiQLI4AAggggAACCAwQ0O1TCm80KcDR7VPqiRPzbVQEOL65+Q8BBBBAAIHRBQhwRjdkDQgggAACCCCAwCABO+fKBjjZnjix9sIhwBm0Z/A+AggggAACOQXsZIIeODnBmA0BBBBAAAEEEBhCIHvOZd8rwFm6dGnUvXAIcIbYWVgEAQQQQACBXgIMYtxLhdcQQAABBBBAAIFyBez2qenpaZcNcHT7lAY21hTjH9QIcMrdj1gbAggggEDCAgQ4CTc+VUcAAQQQQACBWgQssLHbpOxn9cDJBjj2fi2FqmkjBDg1QbMZBBBAAIH4BQhw4m9jaogAAggggAACzQqo940m62GTDXDUI8fOx2IczJgAp9l9j60jgAACCEQkYCcMdkIRUdWoCgIIIIAAAggg0LhAd1ijAnW/tmzZsmhvoyLAaXwXpAAIIIAAArEIEODE0pLUAwEEEEAAAQRCFOh1rtUd4Kjc1ksnttuoCHBC3CspEwIIIIBAKwV6nVS0siIUGgEEEEAAAQQQCFAgO3ixFc8CnGxYY+dksd1GRYBjrc5XBBBAAAEERhSwkwVuoRoRksURQAABBBBAAIEugV5BjWZZ7HWFPQQ4XYj8iAACCCCAAAL/FiDAYU9AAAEEEEAAAQSqEdB5lqbJycl5G1gswMm+vnr1anfNNdfMW66NP9ADp42tRpkRQAABBIIUIMAJslkoFAIIIIAAAghEIKDBiWdnZxfUJBvUdL+/2DILVtKSFwhwWtJQFBMBBBBAIHwBApzw24gSIoAAAggggEBcAv0CnLhq6hwBTmwtSn0QQAABBBoTIMBpjJ4NI4AAAggggECiAgQ4iTY81UYAAQQQQGAUAQKcUfRYFgEEEEAAAQQQKC5AgFPcjCUQQAABBBBIXoAAJ/ldAAAEEEAAAQQQqFmAAKdmcDaHAAKLC2jgLSYEEGiHwMEHH+y22WYbt2LFikoL3D1AX6UbY+UIIIAAAggggEDAAgQ4ATdOiEXrd4E9Pj4eRJGXLl0aRDmKFCIUuyJlZl4EEEhbYM2aNW7JkiVpI1D7xgVWrVrVeBkoQPUCc3Nz1W+ELQQtUMbvOn8QCLqJKVxOAQKcnFCpzaagZmJiwlebcKGdrV/GB10VNddJWKhlq6K+rBOBWAXq6oFT1I/PrKJi8c2/2B9y2Dfia2tqhMAoAjoftfNSwp1RJFm2TgECnDq1A97WYoFN9kLb/vqRfa2KKtVxgrXYyV1b61NFuVlnMYGqfy+KlYa5Eahe4AEPeIDbaKONCGSrp3Z1fC7WUA02gUBugRg/U+08OjdCYDO2uU2yx1BdA2R/zjLPzMz4H6enp7Mv8z0CQQnYGIS6hT324JHHiPfY9Sy46T6Q6SCtg1jsO0UPkihf6nfrW9MV7t73mi5PmduvMygss9ysC4E8AgQ4eZTyzdP2C7t8tSx/rjZfUI6qwfnZqIIsj4Bz6snQK9DRNRAhDntIqAIEOKG2TMXl6hXcENpUjM7qEUAAgYgE7ARi+fLlEdWKqiCAAAIIpCjQK8whyElxTwi/znb+RQ+c8NuqtBLafXPZFaawA2Try/cIIIAAAqMJ2AkEAc5ojiyNAAIIIBCOANdJ4bQFJektYOdfKVy/cwvV7ftA90FJvW4mJyd77x28igACCCCAwCICdgJBgLMIEC8jgAACCLRWIHvNxPVSa5sxyoLb+RcBTpTNO79S2QOR3qFb4HwffkIAAQQQyC9gJxAEOPnNmBMBBBBAoD0CGnJiamrKF5gQpz3tFntJ7fyLACfylia8ibyBqR4CCCBQs4CdQBDg1AzP5hBAAAEEahMgxKmNmg3lFLDzLwKcnGBtnW3lypX+Ua964g89b9raipQbAQQQCEcgpROIcNQpCQIIIIBA3QLZP4SncNFcty/bKyaQ0vlXsmPg2EFHXf8U4PDX0mK/JMyNAAIIILBQIKUTiIW15xUEEEAAgZQEstdTjB+aUsuHV9eUzr+SDXDU+8Ymet+YBF8RQAABBEYRSOkEYhQnlkUAAQQQiEPAPve4noqjPdtaC9sPU+gNlmSAY2mxdlAONm39NaXcCCCAQHgCKZ1AhKdPiRBAAAEE6hbIjofDHQ1167M9E7DzrxT2wSQDnGzvmxQa2XZsviKAAAIIVCtgJxAp/AWoWknWjgACCCDQFgE++9rSUvGW0/bBFK7tkwtw6H0T7y8uNUMAAQSaFrATCAKcpluC7SOAAAII1CVgvXB4rHhd4mynW8DOvwhwumUi+JkAJ4JGpAoIIIBAoAJ2AkGAE2gDUSwEEEAAgUoE7A6HFC6gKwFkpSMJ2PlXCvtfcj1wrHG1h6TQwCP9JrAwAggggEAhAfuMIcApxMbMCCCAAAItF+Dzr+UN2PLi2/6XwvV9cgGOpcMMXtzy31KKjwACCAQoYCcQBDgBNg5FQgABBBCoTIDbqCqjZcU5BOz8iwAnB1abZrEDi8rMyXWbWo6yIoAAAu0QsBMIPmPa0V6UEgEEEECgPAH9oZxxcMrzZE35Bez8iwAnv1kr5swGOCk0bisahUIigAACEQnYCQQBTkSNSlUQQAABBHIJ2Gcg11m5uJipRIGU9r2kbqGyAIdkuMTfFlaFAAIIINARsBMIApwOCd8ggAACCCQiYJ+BBDiJNHhA1Uxp3yPACWjHoygIIIAAAu0WsHHWCHDa3Y6UHgEEEECguIA97ZfPwOJ2LDGagJ1/pRAeJhngMIDxaL8gLI0AAggg0FvAenpy8trbh1cRQAABBOIV4DMw3rYNvWYEOKG30JDls4MKAc6QgCyGAAIIIDBQQJ81s7OzA+djBgQQQAABBGIS4ForptZsV10IcNrVXrlLawcV/jKam4wZEUAAAQQQQAABBBBAAIFcArqQ5o/luaiYqUQBApwSMUNaFQFOSK1BWRBAAAEEEEAAAQQQQCAmAQ0mOzc356anp2OqFnUJXIAAJ/AGGrZ4BDjDyrEcAggggAACCCCAAAIIINBfgB44/X14txoBApxqXBtfKwFO401AARBAAAEEEEAAAQQQQCBSAQKcSBs28GoR4ATeQMMWzwKcFB4vNqwRyyGAAAIIIIAAAggggAACwwgQ4AyjxjKjChDgjCoY6PIEOIE2DMVCAAEEEEAAAQQQQACB1gsQ4LS+CVtZAQKcVjbb4EIT4Aw2Yg4EEEAAAQQQQAABBBBAYBgBApxh1FhmVAECnFEFA12eACfQhqFYCCCAAAIIIIAAAggg0HoBApzWN2ErK0CA08pmG1zo/fbbz01MTDjGwBlsxRwIIIAAAggggAACCCCAQBEBApwiWsxblgABTlmSga2HACewBqE4CCCAAAIIIIAAAgggEI0AAU40Tdmqimi/W7VqlZucnGxVuYcp7JKxsbE1wyzYxmUIcNrYapQZAQQQQAABBBBAAAEE2iBAgNOGVoqvjAQ48bWprxEBTqQNS7UQQAABBBBAAAEEEECgcQECnMabIMkCEOBE2uwEOJE2LNVCAAEEEEAAAQQQQACBxgUIcBpvgiQLQIATabMT4ETasFQLAQQQQAABBBBAAAEEGhcgwGm8CZIsAAFOpM1OgBNpw1ItBBBAAAEEEEAAAQQQaFyAAKfxJkiyAAQ4kTY7AU6kDUu1EGhAYNmyZQ1sdbRNjo+Pj7aCiJdeunRpxLWrt2pzc3P1brAFW9OTMdo0zc7Otqm4lBUBBAISIMAJqDESKgoBTqSNTYATacNSrXkCvYKFOi/c674QrrNu86D5AQEEEEBgZIGqw606A8V+dSEUG3lXYQUtESDAaUlDRVZMApzIGtSqQ4BjEnyNRUBhzcTEhK8OQcbwrdrvpHv4taa3JPtgem1OjRFAIL/AzMyMn3l6ejr/QsyJQMsECHBa1mARFFfXQ1NTU07n85OTkxHUqH8VloyNja3pP0s87xLgxNOWqdfE9uWsg4UQdoJo7/FXP5PgKwIIINCsQK8eks2WiK1XLWDBtv2xxbanz2qCHNPga0wCBDgxtWY76kKA0452GqqUdtG7fPnyoZZnIQSaFrAeN3ZCqNDGAhuCmqZbh+0jgAACCCCwuICdh9ochDgmwdeYBAhwYmrNdtSFAKcd7TRUKe2DkwBnKD4WaljADk4qhgU3hDYNNwqbRwABBBBAoKCAnY9qsRUrVjg+ywsCMnvQAgQ4QTdPlIWzayRuoYqwee0DkwAnwsZNoEonnXSSU88b/mKXQGNTRQQQQACBqAXsnDSVC46oG5PKzRMgwJnHwQ81CBDg1IDc1Cbsw5IAp6kWYLvDCti+S3gzrCDLIYAAAgggEJaA/WGGXjhhtQulGU2AAGc0P5YuLkCAU9ysNUvYRTABTmuajILeIWAneey77BIIIIAAAgjEIWAXHfxxJo72pBb/FiDAYU+oW8COpan0aOQpVHXvYWwPgSEE+DAcAo1FEEAAAQQQCFxAn++pXHQE3hQUryQBzllLgmQ1uQUIcHJTtW9GeuC0r80osXPst+wFCCCAAAIIxClAD9s42zXlWhHgpNz6zdSdAKcZ91q2yoVwLcxspGQB9tuSQVkdAggggAACgQjYhQfj4ATSIBRjZAECnJEJWUFBATuOptKbkVuoCu4gzI5A3QIEOHWLsz0EEEAAAQTqEbALDwKcerzZSrUCtj8zrlO1zqx9voDtdwQ4812i+IkL4SiaMblK2EGJAYyTa3oqjAACCCAQuYB9xhPgRN7QiVTP9mcCnEQaPJBq2n5HgBNIg5RZDAKcMjVZV10CdlAiwKlLnO0ggAACCCBQj4B9xhPg1OPNVqoVsP2ZAKdaZ9Y+X8D2OwKc+S5R/ESAE0UzJlcJOyhxcpdc01NhBBBAAIHIBfiMj7yBE6ue7c8EOIk1fMPVTW2/Ywychnc4No/AIAELHglwBknxPgIIIIAAAu0S4DO+Xe1FafsLpHYh3V+Dd+sSSG2/I8Cpa89iOwgMKcDJ3ZBwLNY6gbvc5S5uq622cptvvrlbZ5113JVXXukuvvhid+2119ZWl4022sgtWbLE/e1vf6ttm1VuaNNNN/X1ueqqqwptZu2113ZqD01///vf3T//+c9Cy2vmIttef/313V3veld3/fXXuxtvvLHwtlgAgbYK8Bnf1paj3L0EUruQ7mXAa/ULpLbfEeDUv4+xRQQKCXByV4iLmVsosNZaa7lnPetZ7oADDnC6kO+evvSlL7kPf/jD7rrrrut+q/Sf9fhTTU972tPcDTfcUPr6616h1eeJT3yiu+2223Jv/jnPeY6bnJz0859yyinutNNOy72szVhk27vvvrtTL8OPfvSj7mMf+5itgq8IRC9w0kknufHxcb//z87ORl9fKhi3QGoX0nG3Zntql9p+R4DTnn2TkiYqQICTaMMnVO299trLvfKVr/Q1vuCCC9yFF17o7nSnO7ltttnGbb/99v51vaYL/FtuuaVSGQsdUg9wFJjJX9Nll13m9tlnn8LuZpknPCLAKczLApEIEOBE0pBUwwvYhTS3/bND1Clg+10qYy8R4NS5d7EtBIYQIMAZAo1FWiOwwQYbuLPPPtuXt1dPj0c/+tHuuOOO8++fcMIJ7stf/nKldbPQIeUA5/73v7/vCZOFfvnLX+4uuuii7EsDvzdLApyBVMyQsAABTsKNH2HV7UKaACfCxg24SrbfEeAE3EjDFs0uhHkc87CCLNeEgO23fBg2oc82qxbYYYcd3Lvf/W73j3/8w+m2HX3tnt72tre5nXfe2X3hC1/w82bf11gt97vf/dwWW2zhb7G65JJL/Dgq2Xnse/Xq2Xbbbf2YLprvX//6l73V+WqhQ68AR7d6aXyejTfe2P3+978feqyWzTbbzN3nPvdxv/3tb3uOtaPxf9Zdd1138803+7Fn1ltvPbf11lu7m266yV166aWLjkej8slB9br88st9naw+eUIUQzjwwAPd85//fHfWWWf5cj70oQ91n/70p9373vc+m2XB16Lb3nDDDd29731v37tH9aIHzgJSXkhEgAAnkYZOpJp2Ic05ayINHkg17VqJACeQBimzGNa4BDhlqrKuqgVsv03loFS1J+sPS+BRj3qUO/74431w8+xnP9uHFN0lfNCDHuR23HFH98c//tF961vf6rytcSPe9KY3+UCl8+Lt35x88snujDPO6LykW4Fe8pKXOPXmsUlB0apVq/zYOr/73e/sZWeBR3eAs+uuu/pbuLJj9Oh2L4VLKtegSQMjT0xMOAUp973vfTuzK5D55je/6U499dROoPTiF7/Yl1cXdgqnFGxlp9e97nXuxz/+cfYlH7ho/VY+jRekHk1HHHGEny9vgKPwSL2ctB6dgG+55Zbu0EMP9e0jk16DGSvsybvte97znu4tb3mLD9KsAqrL//3f/7l9992XMXAMha/JCBDgJNPUSVSUACeJZg6ukqldK3ELVXC7IAVCYL5Aagel+bXnp9gFNtlkE/fZz37WV1Pj3Hzyk5/0wYqefNRvsp47muc3v/mNU5jyyEc+0vfq0Guvf/3r3fe//32nW7Q0MK56e2gehQXqAaN59ZQkBR3q/WHBRK8Ax34Htd7vfOc7fpmHPexhPohREHTQQQe5bAik+bonDdJ8yCGH+JdVXz3larvttnOPeMQj/Gsnnnii02DNmhSGaJs2qdzqMaRtqh6aFHbZ07ks8NHrP//5z32gpPqpp5BNeQMcC9TkouDobne7m+/5pPX0Co6KbFtt/ZGPfMSXS27nnnuuX/9OO+1kxSTA6UjwTSoCBDiptHQa9STASaOdQ6ulnael8sduApzQ9kDKg0CXQGoHpa7q82MCAtkQwKr761//2gc5v/zlL9155503r2eObtfRILsaq+Ub3/iGO/bYY/1i6uXymte8xj/RSuHAUUcd5Xu8vPGNb/QDIytosdum7nWve/nbgrSgtq+ARFN3gKNbkj71qU/597IBhnqqvOn23j+Pecxj3Ne//nX31re+1c+z2H+nn366D1+y69C8CnUU7qgXjnqmaMoGOLq4061ja9ascXrE+Sc+8QkfgGi5888/393jHvdwn/vc5/xy73jHO/xtT/pB877zne/0IZF+zhvgqB6q08c//nEftmhZjT2kkCVrrdeLblsDVWvAagVur33taztPFVPZ1EaaeAqVZ+C/hAQIcBJq7ASqSoCTQCMHWMXUrpUIcALcCSkSAlmB1A5K2brzfToCCg2e/vSn+54x3bVWbw2FKAovFMDolqoPfvCDfjaFH9nHi2tsmaOPPtr3cDnssMP8k5TUW0dBkHqy2KRxZTSui3qpvOIVr3C/+tWv/FvdAY7e23vvvX3osP/++9vi/qtuzVKQpOkpT3nKvJDJv5j5T71ZNAaPet9Ybx+9rdf1uO4f/ehH7vDDD/dLWICj8ip0yk4KOhR4vOc973Gf+cxnfNlURvW8edWrXpWd1T3kIQ9x733ve/1reQIcWXzxi1/082dDLd0+Zrdi7bbbbn4MIc0kl7zb1vwKqTT1GhtB4yCpnQhwPBH/JSRAgJNQYydQVQKcBBo5wCqmdq1EgBPgTkiREMgKpHZQytad79MTuPOd7+we+MAH+p4jD3/4w33PD1OwXiGPe9zj3Jvf/GYf3CjAyTMp9Hnwgx/se8FoIGINzGu3GPULcNSrRbcj6fauH/7whws29dKXvtS/pvFbVq9eveD97AsauFe3QWlcG90KpbBJ5dDUK8DROD4azyc76WlQL3zhCztBh4IVBSwf+MAHOj2FbH4N8GxjBuUJcCxMUmAmX5vkZAGOxvw555xz/FtFtq2xb6wn0+Mf//hOTyjbxote9CInSwIcE+FrKgIEOKm0dBr1JMBJo51Dq2Vq10oEOKHtgZQHgS6B1A5KXdXnx8gFFDLo1if1rLHbm7JVHhsb82GCBR1PeMIT3J577un0pCSNZ6NbkvpNWl5Bg401Y/NqzBrdgqWpX4CjXj/ZQYdt+e6vL3vZy/xAvN2v289PetKT/GDANsiwXldQcvXVV/v19wpweoUZ2s4+++zTCTrUE0c22TF0bJv6+tWvftUPSJwnwNH2zCS7juz3P/vZz/xtanqtyLa33357NzU15ev81Kc+NbtK//0znvEMf1tVrzovmJkXEIhIgAAnosakKo4Ah52gCYHUrpUIcJrYy9gmAgUEUjsoFaBh1ggE1HNEj/bOjt/SXS31WnnXu97lX1bvE50g6vaoyy67zIcZ3fOrp4vCoBtvvNGHP+qx8+c//9nfgjU3N+euuOIKf7uTBRb9Ahz1gFH4cOaZZ3ZuL+renn7Wk6iyt0Zl51F5vvKVr/iXzj77bH8r0cUXX+z+8pe/OA0afNxxx/XsgaMBf9XrKDt1Bzga/+exj32s+/znP+90IZidivTAyd4OpoGku8M0jXej26c0KUC76qqr/NhDebetXkfy1vTc5z7XB1f+hzv+owdOVoPvUxIgwEmpteOvKwFO/G0cYg1Tu1YiwAlxL6RMCGQEUjsoZarOtwkIaNwXBQPf/e53/dg1vaq81VZbOT1ZQJNumdLPFlZ0hwEW9iikecELXuC+/e1v++Ve/epXO4U3NmkMnK997Wv+x34BjoIijc3z05/+1PegseX1VQMFH3DAAT7sUHm6Qw+b125Nmp2d9eO/2Ov6agM49+qBkyfAsUBH9dXjvLNTkTFwbIDhn/zkJz4cy65H3ysMUgilHkTvf//7nQZlLrJtjf+j3kCajjnmGP80L//DHf/993//t9Mtc/TAyarwfQoC9hnfa2yoFOpPHeMSIMCJqz3bUhs7jupccXp6ui3FHrqcBDhD07EgAvUIpHZQqkeVrYQiYOPZqDy6xcaeqGTl02OsdZvUzjvv7HvOKKTIDkD8oQ99yPes0fx6MpQGw9UtRVqPbvGxACc7doueYqXAQj1JNPULcOyx2ppPgdDll1+ub53WoQsuPc47e1uRf7PrP23n4IMP9uXXOizo0e1K6lmkMWaGDXD0KHIFKpo0GPKqVav89xpLSE+h0sm0pn63UClc0SPMFc7oKVR6qlavSetXGGU9n4puW+XRrWwKifSY91tvvdVvRq/pPU0EOJ6B/xISsM94ApyEGj3iqhLgRNy4AVfNjqMEOAE30rBFs8Zdvnz5sKtgOQRqF7D9NpWDUu3AbLBxAQ2YqyBH06WXXuoHDL722mvdlltu6Qf9tXFjXvKSlziNXaNpl1126fTY0SPDdYuUxlbRvBpbRvPqtiZbt17T7Uu33XabDxF0S49NCnl025Aeb939FCrNYwMZax3/+7//65/CpMdq69YqTdly+Re6/lNQY7cP6WlR6s2jW5b05C2btG7No4GLJyYmnH7v8/TA0fJ66pY8NJ111lnuT3/6k7+tKjueTb8AR+GYAi5NMlRZek12Yq739EQueRXZdrYnlZbVoNAK6LIDURPg9JLntZgF7DOeACfmVk6nbvY5wf6cTpuHUFM7jqZyrUQPnBD2OsqAQB+B1A5KfSh4K1KBdddd1+2+++5+YOJeVVSPDXWJ1ZOgspPC+COPPNKHNva6Ah4N6GvzauwW9SpRbxGb9Nhx9Xy55ZZb/O08Cn10C4/CGQtwso/LVo8f9dJR75PspJ4o6jV03nnnZV/u+b1CikMOOWTee9/73vd8WXVLkR6hreBEAYrdVtUrwFFwoideZd+Tn24R00DA2UmPHNeTnRRWafDnxcboedOb3uT0ZCg9XcqCnOx67HvdRqWeTeoxdOqpp/pHqBfdtkIvbcOeAKZ169YyBU/qlZOtl22XrwjELGCf8VzwxtzK6dSNACedtg6ppnYcJcAJqVVKKos1Lj1wSgJlNbUI2H6bykGpFlQ2EqSAghQ98UmP2NZtPddcc42/XUe9axabFCpombvf/e6+58mVV17ZuUXJltHtTuqNsummm/oePuqZs2bNGv/2Xe5yF6dHXOu1m266yRbp+VWhg9azwQYb+G2pF4mtp+cCXS+qjFtvvbXvBXTRRRfN254eKa7eQSr/sNMmm2ziH8GugEpB1s033zzsqgovV2TbatsHPOABTuGaDNVjiAmBVAXsM54AJ9U9IK56E+DE1Z5tqY0dR1O5VqIHTlv2TMqZrEBqB6VkG5qKI4AAAggkJ8AFb3JNHnWF2Z+jbt5gK5fatRIBTrC7IgVD4N8CdlDir3PsEQgggAACCMQlwAVvXO2Zem3Yn1PfA5qpv10r0QOnGf9Kt2qNyy1UlTKz8pIFbL8lwCkZltUhgAACCCDQsAAXvA03AJsvVYD9uVROVpZTwK6VCHBygrVpNmtcApw2tRpltf2WAId9AQEEEEAAgbgEuOCNqz1Trw37c+p7QDP1t2slApxm/CvdqjUuAU6lzKy8ZAHbbwlwSoZldQgggAACCDQswAVvww3A5ksVYH8ulZOV5RRI7VqJMXBy7hjMhkBTAnwYNiXPdhFAAAEEEKhWgM/4an1Ze70C7M/1erO1fwsQ4ES8J1jj0gMn4kaOsGp8GEbYqFQJAQQQQACB2wX4jGc3iEmA/Tmm1mxPXewaP5W7FeiB0559k5ImKsCHYaINT7URQAABBKIXSO3CI/oGTbyC7M+J7wANVf+kk05y4+PjjgCnoQaocrN2UKEHTpXKrLsKgZUrV7pVq1a5ycnJKlbPOhFAAAEEEECgAYHULjwaIGaTNQrYtVYqF9I10rKpPgKpHUfpgdNnZ+AtBEIRIMAJpSUoBwIIIIAAAuUJ6PNdExe85ZmypuYECHCas095ywQ4Ebe+HVTogRNxI0datdQOTJE2I9VCAAEEEECgI2DnpXqBc9MOC9+0WMD2aQLJFjdiC4ue2nUSPXBauJNS5PQEbBwcbqNKr+2pMQIIIIBAnALW+4bP9jjbN8VaEeCk2OrN15kAp/k2qKwEdlDhrxyVEbPiCgXs4MT+WyEyq0YAAQQQQKAGATsn1aZmZmbc9PR0DVtlEwhUK2D7NT1wqnVm7fMF7Boplf2OHjjz25+fEAhWgF44wTYNBUMAAQQQQKCQgPW+0UKpXHQUAmLmVgoQ4LSy2VpfaAKc1jfh4hWwgwo9GBY34p2wBWwfprt12O1E6RBAAAEEEFhMwC429D69bxZT4vU2Cth5KqFkG1uvvWW2Y2oq+x09cNq7r1LyRAXsw1HV58Qv0Z2AaiOAAAIItFLAPsP1h5jx8XEGL25lK1LoxQRs/07lQnoxB16vV4AAp17vWrdmBxV64NTKzsYqELADlVatEEcT9897Bv5DAAEEEEAgOAHdBj0xMeFDGyscf4QxCb7GImDXWgQ4sbRoO+ph10Wp7Hf0wGnHfkkpEVggYB+S2TcIc7IafI8AAggggEAzAgpsbOoObvQ64Y3p8DUmATs3TeVCOqa2a3NdCHDa3HoDym4HFXrgDIDi7VYJ2H5dR6HV5bst09zcXFuK2recbTLvW5ES3pydnS1hLawCgfIEshfp5a21+TXp1p6QpqVLlzZSnLId7Hiu8IbjWSNNykYrFrBzUgKciqFZ/TwBApx5HHH9YAcVApy42pXazBfQBUXZJ53zt/Cfn5o6qf5PCfJ9V5dHvtIwFwIIIIDAsAIWggy7fN7lyvwjgJWZ0CavPvO1VcCutQhw2tqC7Sw3AU472y1Xqe2gQoCTi4uZEEAgIIFY/9Lfj5jgrZ8O77VVwC7m21h+Aog2thplRqA+AbvWIsCpz5wtOUeAE/FeYAcVApyIG5mqIYAAAggggAACCCCAQO0Cdq1FgFM7fdIbJMCJuPntoEKAE3EjUzUEEEAAAQQQQAABBBCoXcCutQhwaqdPeoMEOBE3vx1UCHAibmSqhgACCCCAAAIIIIAAArUL2LUWAU7t9ElvkAAn4ua3gwoBTsSNTNUQQAABBBBAoFQBzp9K5WRlCEQrYMcKApxomzjIihHgBNks5RTKDioEOOV4shYEEEAAAQQQiFvAToxVSy7K4m5raofAqAJ2rcWxYlRJli8iYJ9TqVzjLxkbG1tTBKjN89pBJZXGbXNbUXYEEEAAAQQQaFZAT7+bmprqFEJP0JqcnOz8zDcIIIBAVsCutQhwsip8X7XAypUr/SZSucYnwKl6j2L9CCAwsoBOCJYuXcqFw8iSrAABBBDIL9Ad4GhJLszy+zEnAqkJWICTyoV0au0ban0JcEJtmRLKxUGlBERWgUDNAvZ7y19+a4ZncwggkLxArwCHY3HyuwUACCwqYOdsBDiLEvFGBQIEOBWghrJKDiqhtATlQCC/gB2UuWjIb8acCCCAQBkCdt5k65qZmXETExP0wjEQviKAwDwBO2YQ4Mxj4YeKBexaIZX9jluoKt6hWD0CCAwvYCcCtga67psEXxFAAIHqBewYrAB9fHzcBzcaE4dAvXp7toBAGwXsmJHKhXQb2yjGMhPgxNiqd9SJg0rEjUvVm8gmRAAAQABJREFUohSw31mrHBcNJsFXBBBAoHoBOym2AEcXZfa0DwL16v3ZAgJtE7DzNgKctrVcu8trn1Wp7HdJ9cCxk45UGrfdv4qUPnUBOwnoduD3t1uEnxFAAIHyBbLj32QDHHudQL18c9aIQNsF7NyNc7W2t2S7yk+A0672KlRaApxCXMyMQKMCdhJgFw5WGP7qaxJ8RQABBKoTsGOwtmDHYbso43yqOnfWjECbBey4YceKNteFsrdHgACnPW1VuKSccBQmYwEEGhOwg7FdOFhB+KuvSfAVAQQQqE5Ax2A7/tpXuyizXjgE6tX5s2YE2ihAgNPGVmt/me2awT6j2l+j/jXgFqr+PryLAAINCNgJgDatCwQbNFODaGpK5QDtK8t/CCCAQM0CFtBYcGNfs8deC3gmJydrLh2bQwCBUAXs/C17rAi1rJQrHgECnHjackFN6IGzgIQXEAhSwE4A9MhaXThYgKPC2pNQZmdngyw7hUIAAQTaLmDH4O4APXtRxjlV21uZ8iNQvoAdO7LHivK3whoRmC9AgDPfI6qfONmIqjmpTMQCdiDuDnD0s4U5/NU34h2AqiGAQKMCOgZ3H38VnmcvyqyXDrdRNdpUbByBoAQIcIJqjmQKY9cN2c+omCvPLVQxty51Q6CFAvbhr6LrQGwXCeqJo9DGDtJcNLSwcSkyAggEL2DH4GyAo+8nJibmBTiqiP4wpolA3TPwHwLJC9jxI5UL6eQbPBAAuzZIZb8jwAlkx6MYCCDwbwH78NcFw/T09IIAx3rSWaCDGwIIIIBAeQJ2DM4G6BbgdAfndjxO5aS5PGXWhECcAtnjR5w1pFYhChDghNgqJZWJE42SIFkNAhUKdB+Eu3vgdP9cYVFYNQIIIJCcgI7BFqCr8vazeuB0Bzh2PO5+PTk0KowAAl6AAIcdoQmB7muHJspQ5zbpgVOnNttCAIG+AnYxkL14sNeyPW4sjOWioS8nbyKAAAKFBHpdfOnEWMffxQaQ1/sciwsxMzMC0Qr0OoZEW1kqFowAAU4wTVF+Qeyij66+5duyRgTKELAP/kEBTq9Qp4ztsw4EEEAgZQEdWzVln/I3KMBJ2Yu6I4DAfAE7j+Naa74LP1UrQIBTrW+jayfAaZSfjSMwUKDXAXixsIbf54GczIAAAgiMLECAMzIhK0AgGQECnGSaOqiK9rp+CKqAJReGW6hKBmV1CCAwvIAOwNneN1rTYgGOvX7ggQe6Cy+8cPiNsiQCCCCAwKICBDiL0vAGAgh0CfDHtS4QfqxFgACnFuZmNsJBpRl3torAIIF1113Xbbfddm5qamrBY2otqMmOgWPr0wH75JNPdmeccYa9xFcEEEAAgRIFCHBKxGRVCEQuwLVW5A0caPUIcAJtmDKKxUGlDEXWgUB1AgprsmMvaEv9ApzqSsKaEUAAAQQkQIDDfoAAAnkFuNbKK8V8ZQnYdYLWl8rYS9xCVdbew3oQQKASATsw9+qBU8kGWSkCCCCAQEeAAKdDwTcIIDBAgABnABBvly6Q4nUCAU7puxErRACBMgVSPDCX6ce6EEAAgVEECHBG0WNZBNISIMBJq71DqG2K1wkEOCHseZQBAQQWFUjxwLwoBm8ggAACNQsQ4NQMzuYQaLEAAU6LG6+lRU/xOoEAp6U7K8VGIBWBFA/MqbQt9UQAgfAFCHDCbyNKiEAoAgQ4obREOuVI8TqBACed/ZuaItBKgRQPzK1sKAqNAAJRChDgRNmsVAqBSgQIcCphZaV9BFK8TiDA6bND8BYCCDQvkOKBuXl1SoAAAgj8W0ABzszMjJuYmHArVqxY8KRAnBBAAAETIMAxCb7WJZDidQIBTl17F9tBAIGhBFI8MA8FxUIIIIBABQLZAEdBzvT0dAVbYZUIIBCDAAFODK3YrjqkeJ1AgNOufZTSIpCcQIoH5uQamQojgECwArogm5ub8z1wCHCCbSYKhkAQAgQ4QTRDUoVI8TqBACepXZzKItA+gRQPzO1rJUqMAAKxCuiCTNP4+Li/lYoeOLG2NPVCYHQBApzRDVlDMYEUrxMIcIrtI8yNAAI1C6R4YK6ZmM0hgAACiwoQ4CxKwxsIINAlQIDTBcKPlQukeJ2QXICjvWhycrLynYkNIIBAOQIpHpjLkWMtCCCAwOgCBDijG7IGBFIRIMBJpaXDqWeK1wkEOOHsf5QEAQR6CKR4YO7BwEsIIIBAIwIEOI2ws1EEWilAgNPKZmt1oVO8TiDAafUuS+ERiF/ADsyq6fLly+OvMDVEAAEEAhIgwAmoMSgKAoELEOAE3kARFs+uE1atWpXMXTYEOBHuyFQJgZgE7MCsOhHgxNSy1AUBBNogQIDThlaijAiEIUCAE0Y7pFQKu04gwIm01e0khDFwIm1gqhWlgB2YVTkCnCibmEohgEDAAnbuxFOoAm4kioZAIAIEOIE0RELFsOsEApxIG91OQghwIm1gqhWlgB2YVTkCnCibmEohgEDAAnbuRIATcCNRNAQCESDACaQhEiqGXScQ4ETa6HYSQoATaQNTrSgF7MCsyhHgRNnEVAoBBAIWsHMnApyAG4miIRCIAAFOIA2RUDHsOoEAJ9JGt5MQApxIG5hqRSlgB2ZVjgAnyiamUgggELCAnTsR4ATcSBQNgUAECHACaYiEimHXCQQ4kTa6nYQQ4ETawFQrSgE7MKtyBDhRNjGVQgCBgAXs3IkAJ+BGomgIBCJAgBNIQyRUjP32289NTEw4ApxIG91OQghwIm1gqhWlAAFOlM1KpRBAoCUCdu6k4s7Nzbnp6emWlJxiIoBA3QIEOHWLsz0CnMj3ATsJIcCJvKGpXlQCBDhRNSeVQQCBlgnYuZMVm3Mok+ArAgh0CxDgdIvwc9UCBDhVCze8fjsJ4eSj4YZg8wgUECDAKYDFrAgggEDJAnbuZKvlHMok+IoAAt0CBDjdIvxctYAFODMzM8n0EF0yNja2pmrYUNZvJyGcfITSIpQDgcECBDiDjZgDAQQQqEpAJ8dLly7trJ5zqA4F3yCAQJcAAU4XCD9WLkCAUzlxsxsgwGnWn60jMIwAAc4waiyDAAIIlCNgJ8caIFITAU45rqwFgRgFCHBibNWw62SfUfTACbudhi4dAc7QdCyIQGMCBDiN0bNhBBBAwNnJMQEOOwMCCAwSIMAZJMT7ZQvYZxQBTtmygayPACeQhqAYCBQQIMApgMWsCCCAQMkCdnJMgFMyLKtDIEIBApwIGzXwKtlnFAFO4A01bPEIcIaVYzkEmhMgwGnOni0jgAACdnJMgMO+gAACgwQIcAYJ8X7ZAvYZRYBTtmwg6yPACaQhKAYCBQQIcApgMSsCCCBQsoCdHBPglAzL6hCIUIAAJ8JGDbxK9hlFgBN4Qw1bPAKcYeVYDoHmBAhwmrNnywgggICdHBPgsC8ggMAgAQKcQUK8X7aAfUYR4JQtG8j6CHACaQiKgUABAQKcAljMigACCJQsYCfHBDglw7I6BCIUIMCJsFEDr5J9RhHgBN5QwxaPAGdYOZZDoDkBApzm7NkyAgggYCfHBDjsCwggMEiAAGeQEO+XLWCfUQQ4ZcsGsj4CnEAagmIgUECAAKcAFrMigAACJQvYyTEBTsmwrA6BCAUIcCJs1MCrZJ9RBDiBN9SwxSPAGVaO5RBoToAApzl7towAAgjYyTEBDvsCAggMEiDAGSTE+2UL2GcUAU7ZsoGsjwAnkIagGAgUECDAKYDFrAgggEDJAnZyTIBTMiyrQyBCAQKcCBs18CrZZxQBTuANNWzxCHCGlWM5BJoTIMBpzp4tI4AAAtmT46VLl7rJyUlQEEAAgZ4CXGv1ZOHFCgWyn1HT09MVbimcVS8ZGxtbE05xqi0JB5VqfVk7AlUIEOBUoco6EUAAgXwC2ZPjiYkJt3z58nwLMhcCCCQnwLVWck3eeIWzn1EEOI03R/kF4KBSvilrRKBqAQKcqoVZPwIIILC4gB2D1T2dAGdxJ95BAAHnuNZiL6hbgACnbvGat8dBpWZwNodACQJ28aBV8ZffEkBZBQIIIFBAwI7BBDgF0JgVgUQFuNZKtOEbrDYBToP4dWyag0odymwDgXIF7OJBayXAKdeWtSGAAAKDBOwYrEGMx8fHOQ4PAuN9BBIW4For4cZvqOra5/TZxCDGDTVA1ZvloFK1MOtHoHwBu3jQmglwyvdljQgggEA/ATsGE+D0U+I9BBCQANda7Ad1CxDg1C1e8/Y4qNQMzuYQKEHALh60KgKcEkBZBQIIIFBAwI7BBDgF0JgVgUQFuNZKtOEbrDYBToP4dWyag0odymwDgXIF7OJBayXAKdeWtSGAAAKDBOwYTIAzSIr3EUCAay32gboFCHDqFq95exxUagZncwiUIGAXD1oVAU4JoKwCAQQQKCBgx2ACnAJozIpAogJcayXa8A1WmwCnQfw6Ns1BpQ5ltoFAuQJ28aC1EuCUa8vaEEAAgUECdgwmwBkkxfsIIMC1FvtA3QIW4KxYscLNzs7WvflGtrdkbGxsTSNbbmCjHFQaQGeTCIwoYBcPWg0BzoiYLI4AAggUFLBjMAFOQThmRyBBAa61Emz0hqtMgNNwA1S9eQ4qVQuzfgTKF7CLB62ZAKd8X9aIAAII9BOwYzABTj8l3kMAAQlwrcV+ULcAAU7d4jVvj4NKzeBsDoESBOziYWZmxk1PT5ewRlaBAAIIIJBXwI7BBDh5xZgPgXQFuNZKt+2bqjkBTlPyNW2Xg0pN0GwGgRIF7OIhpXtbS+RjVQgggMBIAnYMJsAZiZGFEUhCgGutJJo5qEoS4ATVHOUXhoNK+aasEYE6BHQBkcrAZHV4sg0EEEAgrwABTl4p5kMAAa612AfqFiDAqVu85u1xUKkZnM0hgAACCCCAQKsFLMDRbawTExOMRdbq1qTwCFQrwLVWtb6sfaEAAc5Ck6he4aASVXNSGQQQQAABBBCoWIAAp2JgVo9ARAJca0XUmC2pCgFOSxpq2GJyUBlWjuUQQAABBBBAIFWBlStXOuuBw3hkqe4F1BuBwQJcaw02Yo5yBQhwyvUMbm0cVIJrEgqEAAIIIIAAAoELKMCxQYwJcAJvLIqHQIMCXGs1iJ/opglwIm94DiqRNzDVQwABBBBAAIHSBQhwSidlhQhEKcC1VpTNGnSlCHCCbp7RC8dBZXRD1oAAAggggAACaQkQ4KTV3tQWgWEFuNYaVo7lhhUgwBlWriXLcVBpSUNRTAQQQAABBBAIRoAAJ5imoCAIBC3AtVbQzRNl4QhwomzW/1SKg8p/LPgOAQQQQAABBBDII0CAk0eJeRBAgGst9oG6BQhw6haveXscVGoGD2hzegxq3ml2djbvrMyHQFQCRX5PRqk4v2Oj6LEsAvULEODUb84WEWijANdabWy1dpdZn0+aUhpgf8nY2Niadjdb/tJzUMlvFcOcuhidmJhw4+PjpVVHT+EYNM3NzQ2aZcH7eda7YCFeWFSgzDZfdCN3vLF06dJBs5Tyfp11KqXAOVai/d5+X6anp3MswSwIINCEAAFOE+psE4H2CXCt1b42a3uJCXDa3oIDys9BZQBQJG8ruJmamppXGwtIdLFo38+b4Y4fBl0k97tYH7Rsr+3xWpoC/fbBUUQsDBllHdllqyqnflf0u5T9ndG2VH6CnGwL8D0CYQgQ4ITRDpQCgdAFuNYKvYXiKx8BTnxtOq9GHFTmcUT5w3777ed73ahydvE5MzPjQrplY5TbVLIXvFE2YI9KWTv2eKvSl0LaZyqtaMMr1++sJvWWs0m/swQ5psFXBJoXIMBpvg0oAQJtEOBaqw2tFFcZCXDias8FteGgsoAkqhey4Q0XgFE1LZVJRIDf4UQammq2ToAAp3VNRoERaESAa61G2JPeKAFO5M3PQSXeBrYLP/XWCK3HTbzq1AyBagR0rFZvM/0+T05OVrMR1ooAArkFCHByUzEjAkkLcK2VdPM3UnkCnEbY69soB5X6rOvcUnbMm+XLl9e5abaFAAIVCRDiVATLahEYQoAAZwg0FkEgQQGutRJs9IarTIDTcANUvXkOKlULN7N+u9BL6fFxzUizVQTqFbDfbXri1OvO1hDoFiDA6RbhZwQQ6CXAtVYvFV6rUsACnJT+iM9jxKvco1h35QLW+4YxbyqnZgMI1C5gv9/aMAFt7fxsEIGOgC7K9JQ4DTbO72KHhW8QQKBLgACnC4QfKxcgwKmcuNkNcFBp1r+KrdvYNymlrlU4sk4EQhXQcVvj4RDShtpClCsFATt/0u8iAU4KLU4dERhOwI4VjF83nB9LFRcgwClu1qolOKi0qrlyFZY2zcXETAi0VsB64XAbVWubkIJHIGCftYSpETQmVUCgQgE7VhDgVIjMqucJEODM44jvBw4q8bWpfmn5y3x87UqNEMgK2Iczf/nPqvA9AvUJ2PkTAU595mwJgTYK2LGCAKeNrdfOMts5Ykp3YzAGTjv3VUp9u4D9ZZ6LOnYHBOIW0Akht27E3cbULmwBuygjwAm7nSgdAk0L2LGCAKfplkhn+wQ4kbc1B5W4GpgAJ672pDYILCZAgLOYDK8jUI+AnT8R4NTjzVYQaKuAHSsIcNragu0rNwFO+9qsUIk5qBTiCn5mApzgm4gCIlCKgA1WTm+7UjhZCQKFBez8iQCnMB0LIJCUgC6mGbMuqSZvvLIEOI03QbUFsBMQUuFqnetaOwFOXdJsB4FmBfhdb9afrSNg508EOOwLCCDQT4AAp58O71UhQIBThWpA67QTEAKcgBplhKLYX+VTGrRqBC4WRaC1AgQ4rW06Ch6JgJ0/EeBE0qBUA4GKBAhwKoJltYsKEOAsShPHG3YCQoATR3sS4MTRjtQCgUECBDiDhHgfgWoF7PyJAKdaZ9aOQNsFCHDa3oLtKz8BTvvarFCJ7QSEAKcQW7Azqz11MkkPnGCbiIIhUIqABTgzMzNuenq6lHWyEgQQyC9g508EOPnNmBOBFAUIcFJs9WbrTIDTrH/lW7cTEAKcyqlr2QABTi3MbASBxgWstx0BTuNNQQESFbDzJwKcRHcAqo1ATgECnJxQzFaKgP2BTytL6Q/6S8bGxtaUItiCldgJCAFOCxorRxFTTFxzsDALAtEJEOBE16RUqGUCdv5EgNOyhqO4CNQsQIBTM3jimyPASWAHsBMQApw4GpsAJ452pBYIDBKwAIdHkw6S4n0EqhGw8ycCnGp8WSsCsQgQ4MTSku2oBwFOO9pppFLaCQgBzkiMQSyc6i9sEPgUAoGaBQhwagZncwh0Ceh3cOnSpX7cOW5l7MLhRwQQ6AgQ4HQo+KYGgVSvB7mFqoadi02UL1D0F/Yud7mL22qrrdzmm2/u1llnHXfllVe6iy++2F177bULCrf++uu7O93pTu7vf/+7++c//7ng/WFfuOtd7+oX/dvf/ua/rrXWWm7DDTd0t912m7vxxhuHXW3P5dZee22nOlex7p4bzPmileuWW25xN910U86lhp9N7aj27DVdf/31bs2aZO4g7UUw77W73e1ubr311nPXXHONu/XWW+e91/QPBDhNtwDbT13AfgflQICT+t5A/RFYXIAAZ3Eb3ilfoOj1YPklaGaNBDjNuLPVEQXy/sIqJHnWs57lDjjggJ4X8l/60pfchz/8YXfdddd1SnTyySe77bff3r32ta915513Xuf1Ub5Zd9113de//nW/iqc85Sk+vHjwgx/sTjnlFPeb3/zG7b///qOsfsGyO+ywg3v3u9/tLrzwQnfggQf69xVcbbDBBq6u8GRBoW5/4VGPepQ7/vjj3Ve/+lV33HHH9Zql1Nee85znuMV63P3jH/9wv/jFL3wbf/aznx05rFMYp/2trcHQW9/6VveYxzzGrVixws3OzpbaDtmVWXD5r3/9y91www3Ztxb93i4euXBclIg3EKhUwH4HdRvj3NwcT4OrVJuVI9BeAQKc9rZdG0ue93qwjXXrV2YCnH46vBesQN5f2L322su98pWv9PW44IILfKChXhnbbLOND2n0hkIOXbQq2NAUa4DztKc9zb3uda9zZ599tg9RfGVr/q/JAOeKK67o1HbjjTeeF+j9+Mc/dscee6wPXzozFfxGoZR6+7zgBS9wl19+ecGlm5+9rgDnvve9r/vEJz7hQ1OFq3kmu3gkwMmjxTwIlC9gv4MKcDQtFoyXv2XWiAACbRIgwGlTa7W/rHmvB9tf0/k1IMCZ78FPLRHI8wur3iYKKzSpp8tpp502r3aPfvSjO71ATjjhBPflL3/Zv7/FFlv4nip/+MMfnHpplDEtWbLEbb311r6Hxm9/+1t/606VPXB0K4wulFV+1UNTygHOr3/9a98Ly9pS7bHpppu6JzzhCZ0eSj/96U/doYcearMU/kqAk4+MACefE3MhEJIAAU5IrUFZEAhXgAAn3LaJsWR5rgdjrDcBToytmkCd8vzC2m1ECjF0K02vMOZtb3ub23nnnd0XvvAFf8uR6HSLhybd4qFJPysQ0c8at0U/qwePxrLJ9urQ+C4W0vz+979fMI5I93oHBTgbbbSR3456c/zpT3/yZcn+Z+XSOD0333yz0/a32247P7aPbk3Jbk/l32233XxPo29+85vuxBNP9Mvc+c539qtUvay+tg2tT+9rnJhedjZf9utmm23m7nOf+ziFVDbWT/b9fj1w1HtFwYrG7bHeULbsoPXafN1f7Raq7gAnO9/y5cvdW97yFv/Sq171Kvfzn/88+7Z3VKi35ZZbur/+9a/ukksumXfrjzl97nOf8z1wdDvcZZdd1neMn2zbaGOqn4INjcukMWiy06B2tnk32WQTP86T2vHSSy91V199tb3V86vm1z62evVqf/tYdw8cq5ft99mV2HsaK6d7vBy9d7/73c/JTLcmyku3lWnSrYT6HfnABz7g39t77717tnd2W/reLh7pgdMtw88I1CNgv4P0wKnHm60g0FYBApy2tlw7y53nerCdNetfagKc/j68G6hAnl9YCwsUPjz72c/ueUH9oAc9yO24447uj3/8o/vWt77la/ue97zHPfShD3WHHHKIO//88/1TN/QEs5/85Cf+30tf+tLO7Te/+93vnEKg+9///u6oo46ap/XGN77R6YNMk27b+sY3vuG/HzQGzuMe9zinW78UxtikC+Ef/vCH7r3vfW8nPNh22239hfCPfvQjp1DmoIMOcro16NWvfrUPQqampjpj4HzmM5/xPU5sffr6jne8wx1++OH+pSOOOMKvP/v+7rvv7gMfhQEvetGLsm/N+16hy8TEhHviE5/oQwh7U8upXKeeemonHLI26R4DJ3urm27z0i1NRdZr2+z+mifA0XY+8pGP+DZUeS3M0bo0FpLaV67ZSUHCJz/5SR807bLLLu7oo4/Ovu3+/Oc/uz322GPea9kfrLeO3NVuCm9s+s53vuMDNgs9+rWzxqJQEHPMMcf4fdbWoa/f/e53nfbbv/zlL9mX3cMe9jCnfdPqpN8PjQWl4E290mwMHGsrjYej17LT05/+dHfYYYfNCz71vh4x/KY3vamzbltGtyWeccYZflypZzzjGfay/6ptK1DsN9nFIwFOPyXeQ6A6AfsdJMCpzpg1IxCDAAFODK3YnjrkuR5sT23yl5QAJ78VcwYkkOcXVhe2GpxWk8a50QW3Tj71dKl+U/cYONaTx5bRBe8vf/lL9/CHP9y/pJ/tSUcKHtTDQLfnaHruc5/re0LkHcRYPXs0qLImhQnqvaD1PfKRj/TbyAYM1oPHz3zHfwp6FIDoCVTZQYw1kLHMFAYoXFAw9cUvftGXTwFEr3FxzKHX7WfZbWocE4VdmuStnjcKnx7xiEf413Rxrot0TRYKZAMc9cJ4xSte4d/PBklF1usX7vFfngBHiz3/+c/3t1Jlwyo9Mvd//ud//Fp/9rOf+Z456lXypCc9yb9mdVBdVdanPvWp/vVzzz3X37b2/ve/3//c6z8LcPSe9h8to15SGkRYk8ZrOvjgg+fdauffuOM/a2f1AFMwov1PvX6+973v+dv/FAIqoNH7L37xi31vKy2q8OZd73qXX4vm13Ye+MAH+vDqjlUXCnC0D9n6sr8nGphb69Z+e+9739uv+vWvf73Tk65URwVFmuSggMhudfQv9vjPLh4JcHrg8BICNQjY7yABTg3YbAKBFgsQ4LS48VpYdLse1GdTSmOzEeC0cGelyM6HEephokm3wCw26eL1JS95yby3dTuNftEVwugpU92Ps7bgwp5Clb0w/fznP+/H09EydtDQyhUQHXnkkf62ED3tSePp6KLaAom8AY6CEIUBCps++MEPdsqt3i3qNaGLfQsKsgGOtq/3Fc5osjLrdXsKVa8xcCxQ0Xqf+cxndm5dUgClXjuanve85/W8hcu/eft/p59+ur9It54z9rrVJRs62fYs/Nh33307T+Ayb1u+yHptme6veQMcBR5vfvOb/eL6Xr1y5K9A7cwzz/Q9n2zdD3nIQzo/W28VvWehTJ5BjG1eue+zzz6d250UBlnw84Y3vMEHMv3aWW2r8EntLG+tT9M97nEPPxi3whP1Lvr4xz/u62Q9jc466yzf60W33+kWLfXakpUmq5O1Vb8eOBbgaB0KHtUTTT3NNCC0Jjm+5jWv8fu0Qir1UmMMHE/Dfwi0SoAAp1XNRWERaEyAAKcx+iQ3bNdiBDgRN79uJ9CUUkIXa3PaL6zq1y/A0fv6i79u+VBvgO5JF7yf+tSn/FNxbAyYfgGOwhO7SNZYH3bblQU1tn79vOuuu/qLcQUReQMc9UzQBa5uo8mOe6ML449+9KN+9Vbf7IW9LpLVS8SmvAFONmzKBjAWfGg8GI0L02/SvLpFrPtR3LYO3eJlt2pZKKAAQ7etWbjWXX5tr8h6FyuflaHfGDhaNrs/qYfNVltt1QnQ1ENIZc1ONl6Mbg+zHlMWyhQJcBRCauyc7CQL3fJn4zIt1s4KTb797W/7RXWb1znnnJNdjbNb4KzuFg5p/91zzz0749JoIQ34bWP4DBPg6FZECxwVQKqHkE26NUu3mKlnlm67GiXAsbLZuvmKAAL1CBDg1OPMVhBouwABTttbsF3lt/N3Apx2tVuh0hLgFOIKemb7hVUhLdAYVGANyKvbRXQhq9ufdtppp84i6qGg3gmaFgtwdMuJektkJ7toV08f3e5kk0JChQfW+yFvgKPlFQwpgNGtU+pBoX/Z8Mnqaxf2uljWtiyA0jryBjiaV70vdKuXemVoXBxNZqCf9fqgacMNN/S352jwWpVXF+0aR0hTrwAnuz7dtqSLA/UG6Z7yrrd7Ofs5b4Dz//7f/3Nvf/vbOz2c1AtHPXJkq0Cie9KYQBoLSbcsqaeMJtsXigQ4vQIJG1/Gnoq1WDtnbxHstU35azwnTaqPwkcFixrLSUFK96Rb7rTfWJksbMvTA2eQV3ZbBDhZDb5HoB0CBDjtaCdKiUDTAgQ4TbdAWtu360ECnIjbnQAnnsa1X1jVyAKN7topCNEtHAo2suGGzTc2NuYv0i1o0COlFSJYeGG39FgY0qs3il20d/fSGDbAUcCkW6F0kZud1ItC49dosvrahb3GG9GTj7KTlXnQLVRaJtszQ+GBxk6xsYP0sw2mm11/9nv1WNHjt20cIL2nXh56CpLqMSjA0fy6bUg9lbJTkfVml8t+nzfAOeCAA5xCELO0cXnUw0WD8nZPFrJkww3bF3qFKd3L27zqCXPVVVfNe1tjB73zne90GiBbPZQWa+dsu9ltddkVKUxTMKlJt+C98IUv9OvL3tKWnV/7nebLE+Co3Bqjx26hsjGENAaUenL1mwhw+unwHgJhChDghNkulAqB0AQIcEJrkbjLY9eDBDgRtzMBTjyNa7+wqpEFGt2106OKFXr060WSHdRVF7h/+MMfFg1wshfrti27EC8rwLEnYCks0i00v/rVr/ytVBqU2AYCtvoudmGvshUJcBRynXbaab7njEIr9Z5RAKWnGHU/XcnqbV/VQ+YrX/mK/1ED0Soc0KOw9eQj9eA47rjjegY4Cnh0a5ae8mS3NGaDj6LrtfJ0f80T4Cjo0+1DCq6mp6edBsq1gMZClO712vg+2V5Lti9k69G9nP1s8+qiSI+cz05PfvKT/VgxuiVOt1Mt1s56rLlu4dKkJzt1P7bdxk2yXkRm0asnmdah27n0e5UnwLHbvCzAMa/F1q32VIh64403cguVsJkQaJkAAU7LGoziItCQAAFOQ/CJbtauBwlwIt4BCHDialx9SGiyQKO7dhp3ZbfddusbRGisE12wa7KxOxbrgVN1gJMd58YeNe4Ldvt/doDSz1bfxS7sNU+RAEfz2y1BConUc0O9kjTgrAae7TdZKNDLxgaQ7tUDRwGGwh2FJwraNFiw1qFgQBf6Rde7WBltPTYOTPd8Cq80kLJuh9I0cfvj0BVA6XHYdryw/SK7rHq2yEnjvmjAaU0WyhQJcPTIcoVe2cn2W+2XCpQWa+fsbXk24HF2Peoho54ydiuW9ezRPPZ0NJtfvac0QLe+WoCz4447+oGOs0/msvntd8QCnKxX97otJNUTsdRThx44pshXBNojQIDTnraipAg0KUCA06R+etu26yMCnIjb3i7I7C/+EVc1iaoNCnBsXA5h9BosVo801u0eO++8s3/csi4uNdnFafctVL1CCrtoL6MHTnYgWJVFF7yaNtpoIz8+i93qNWyAozBL4cAPfvAD/8Qsv/I7/rOLantNPWTUq+PWW2+1l3p+tVtpVFYFF3armsIoPV5avVr6BThaabbeJ5xwgn+CV9H19izc7S8uFuAoONIYMnqK0+Mf/3i/uA0arB8UZOiWLpVfAZMGurbJAgn9rHLaLVAKMzT/y1/+cnfRRRfZ7D2/2n4jN93+dsMNN/j51GNM29NkQcpiAY7mUQimga/VpgpxbBwhPUVMgyurPMccc4wfFDs7ULEGxP7Yxz6mVfjpZS97WWd8J9tu9klk2VDKeghpQQtw9Aj0T3/60357H/rQh/yg4Hpfg2RrbB3tu+rlpN9D29e0j6nnzm233aZZ+0528Wj7ft+ZeRMBBEoXyJ4ka+WcR5VOzAoRiEKAACeKZmxNJbKfTSl9LvEY8dbsohS0W2BQgKP5NRCtghxN6kmgMWGuvfZap9tPdCFu47ZorBHdLqOpqQBHgyyfccYZ/iJYF/Z6HLMeB60LdF2I26QwQbc8bbHFFv6R5jZui72vr7164NiYKXpfY7toW/KwyW4508/dj862ebq/ZnsN6bYv9fZQbxo9+csmXagrMND2bGBc64Fj89hAyppXA0UrXLOnbuVZr62n+6sFON2vd/+skElBR/aR8hZ4aV49FUzO97rXvXywpdcUWLzvfe/Tt37SuDXq5aLbiNRz6ZRTTrG3Fny1AEdv6NHv3//+9/14TTZgcvZR3P0CnOw4N2pL1UNBjW6fUgCjMitQsmDNbnXSdhX6qGeS9ovsINkW4GgePUpe69FtWBr8ePPNN/e3vek9TRbg6Ptddtmlc8ud6q96aWwe/Y6pXfU7pqd5KdSxXkcKRWWh2+/6TQQ4/XR4D4HqBewkWVtK7S+d1euyBQTiESDAiact21AT+2xK7XOJAKcNeydl7CmQJ8DRbSZ6nLJ6WvSadFGq21SyQYaNQ6NxTs4///zO7Us2Jkl2PXYhvtdee7krr7yy85YFEtYbQY/Z1kW5Jrs9ynqeZAMYjQmjR0JnAxsFS3pstXof6BYfTfqquukWnuzy/s3b/7MD2gUXXOAOOugg/3L2diW9cOyxx3bKpJ/16GrdwqQpG2j5F/r8p9BBVtlJT2c68cQTfSiiMEkX8LqYt9t4dMF+/PHHdxbRGCm6FUn1toGDi6y3s6Kub7J16nrLhxIaf0Zj+Gib1nslO5/a6vWvf332Jf+9whn10FmzZk3nPQVtGghYgYXCiz322KPzXvc3tt9o/1BgZUGi5lO4oZ5IMtPUaz/xb9zxnwIetaWCluykOmn8J1uPvffMZz7TDzptP+urwig9llw9irTvzs3N+bcVdKonVXbd+p3RutWbK9trSQtoHz3yyCPn1Uf7r/aF7O+Y9l+FMpp0257e7zfZ/pwNl/rNz3sIIFCugP0Oaq2pnSiXK8naEIhbgAAn7vYNrXb22ZTa5xIBTmh7IuXJLaBb4jT2Rp7bKnSBrFs39IhrhSnXXHON7ymhC+3QJt2Ool4s6kmhW3HU+8Em9cjRLVWrV6/u9Kqw9/J81UW61qGvqrv1zNCy6jWjoGix8WL6rf/ud7+7f+y5bodRmbM9WTQosl7PBlz91pV9r6r1Zrcx6Hu1h8ZKuuc97+lva1NPrmz9sstrP9PTzTSgcL+nd1mAo8BEAz4/4AEP8OGV2tVuncuud9D3CucUtuif9heN49M9qHF2HQrMFAxpP1B79ZtX4wRtttlmPsTRPvOnP/0pu6oF36ss+l1T22letXt2P7MFFNZpcG49rezmm2+2l3t+tQ9oApyePLyIQOUC9juoDaV2olw5LhtAICIBApyIGrMFVbEe2ql9LhHgtGDnpIi9BYoEOL3XwKtZAfX62GmnnXwPoHPOOSf7Ft+XLJANcGwMnZI3EdXq7OKRACeqZqUyLRKw30GdJGtKaayBFjUTRUWgcQECnMabIKkCEOAk0NwMYhxXIxPgjN6e6gWhsV40oK+eHqTeG7r1Z9DgxaNvOe01EOAUa3+7eCTAKebG3AiUJWC/gwpw8vZ8LWvbrAcBBNojQIDTnraKoaQEODG04oA6EOAMAGrZ2/ZLm+cWqpZVrbbi6pabU089tbO9PI8O78zMN0MLEOAUo7OLRwKcYm7MjUBZAvY7SIBTlijrQSBOAQKcONs11FrZtSC3UIXaQiWUiwCnBMSAVmG/tAQ4wzeKxmx53O1P6brlllv82DeXX3758CtjydwCGthZYzFpYGx6Ow1ms4tHApzBVsyBQBUC9jtIgFOFLutEIB4BApx42rINNbFrQQKcNrTWkGUkwBkSLtDF7JeWi7pAG4hiIVCSgF088rteEiirQaCggP0OEuAUhGN2BBITIMBJrMEbrq5dCxLgNNwQVW6eAKdK3frXbSeUXNTVb88WEahTgN/1OrXZFgILBex3kABnoQ2vIIDAfwQIcP5jwXfVCxDgVG/c+BYIcBpvglILYCeUBDilsrIyBIITsA9ofteDaxoKlIiAfd4S4CTS4FQTgSEFCHCGhGOxoQTs/JAeOEPxtWMhApx2tFPeUtoJJRd1ecWYD4F2CujYzZNv2tl2lDoOAfu8JcCJoz2pBQJVCRDgVCXLensJEOD0UonsNQKcyBr09urog2JmZsZNT0/HVzlqhAACXkC/55oYsNwz8B8CtQsQ4NROzgYRaKUAAU4rm621hSbAaW3T5S84AU5+q7bMyQdFW1qKciIwnIB9OGtpApzhDFkKgVEFCHBGFWR5BNIQ4Lw8jXYOpZZ2jsgtVKG0SAXlIMCpALXhVfJB0XADsHkEKhawD2d62lUMzeoRGCBgn7fczjgAircRSFjAjhOTk5MJK1D1ugRSPUdcMjY2tqYu5Ka3Q4DTdAuUv321qU4mGQenfFvWiEAIAjoZ1ESAE0JrUIaUBezCjAAn5b2AuiPQX8COEwQ4/Z14txwBApxyHINeCwFO0M0zVOGy3br5sBiKkIUQCFbAPphVQG6fCraZKFgiAhamqrr8PibS6FQTgYICBDgFwZh9JAE7T0ztj3z0wBlpt2HhEATohRNCK1AGBMoXsAvG1D6Yy5dkjQiMLmC/j1oTAc7onqwBgRgFCHBibNVw60SAE27blFYyeuCURhnUiuyXN7UBrIJqBAqDQMkC9ntNeFMyLKtDYEgBApwh4VgMgYQECHASauwAqprquSI9cALY+SjCaAJ2G5XWQogzmiVLIxCCgH0g8/scQmtQBgT+LWAXZoyBwx6BAAKLCdhxgmENFhPi9TIF7HwxtT/2EeCUuRexrsYECHEao2fDCJQmoN/jiYkJPzA54U1prKwIgVIE7MKMAKcUTlaCQJQCdpwgwImyeYOrFAFOcE1SfoG4hap805DWmA1xVK7U0tiQ2oKyIFBEIBvcaDl+d4voMS8C9QjYhRlPfqzHm60g0EYBO04Q4LSx9dpXZgKc9rVZ4RIT4BQma90C3SGOKqCLQf01X9Ps7Kz/WtV/OpAsXbrU8cFVlTDrjUFAv6ea1NtGky4IbSK8MQm+IhCWgF2YEeCE1S6UBoGQBOw4wXlwSK0Sb1kIcOJt207NCHA6FNF/o19oTXaB2F1hC3S6Xx/l53vd615O/2644Qb329/+1s3NzY2yuqCXrcIv6ArXVLhskFHTJgtvRgHlKFOvOtr+pPCm6pB1lLKzLAIpC9iFGQFOynsBdUegv4AdJwhw+jvxbjkCurbXZ1Jqf/xjDJxy9h/WErCAhTlWxDwXoL0uMm15viKAQG8BC2J6v/ufV7PhppYhtPmPDd8hEKqAXZgR4ITaQpQLgeYF7DhBgNN8W6RQAgKcBFqZHjgJNHJDVdxjjz3cq171qs7WV6xY0fm++5ui4VCewKl7G0V+LlqeIutOad684cWwJtnQo+g6hikboUpRZeZHIG4BuzAjwIm7nakdAqMI2HGCAGcURZbNK0CAk1eqxfMR4LS48QIvut2DacVUgMMFsGnwtQkB2yfZF5vQZ5sIxCdgF2YEOPG1LTVCoCwBO04Q4JQlynr6CRDg9NOJ5D0CnEgaMsBq2AeW9WZRjwc+vAJsqISKZB9q7IsJNTpVRaBCgeznHMFwhdCsGoEWC9hxgnPgFjdii4pu57qMgdOiRitaVAKcomLMn0fAejroQtkCHC3HCW4ePeapSkAnUTaxL5oEXxFAYFgBO4eiB86wgiyHQPwCBDjxt3FINSTACak1KiqLnXyQClcEnOhqLcDRRfLU1FRHgYvmDgXf1Cxg+6Rtll44JsFXBBAYVsBOlLU8n2/DKrIcAnELEODE3b6h1c4+l+iBE1rLlFgeApwSMVlVR0AfVjpw6CJZAY6+2kRYaBJ8rVPAPtCy2+SCK6vB9wggUFQge1zheFJUj/kRSEOAACeNdg6llva5RIATSotUUA4CnApQE1+l9XTQyawmC3B0INH3nOQmvoM0VH2dQNlkt/bRC8dE+IoAAsMI2ImyluWzbRhBlkEgfgECnPjbOKQa2ucSAU5IrVJyWQhwSgZldc4CnOXLl7tly5YtCHC4aGYnqVvA9sle2+Wiq5cKryGAQB4BO1HWvBxL8ogxDwLpCRDgpNfmTdbYPpcIcJpshYq3TYBTMXCCq9cHlR00sgGObp2yg4rCHSYE6hLoDnDslj4GHq2rBdgOAnEK2GeaakeAE2cbUysERhUgwBlVkOWLCNjnkl2LFVm2zfMuGRsbW9PmChQpOwFOES3mHSRgF8p2Itsd4NjP9v6g9fE+AmUI6ORJU/bWKX2w2e19jMtUhjLrQCA9ATtRVs35XEuv/akxAnkECHDyKDFPWQL2uUSAU5ZogOshwAmwUVpcJLtQth42Fthkb5vig6zFDdzColuoqKJnA5xsjzAuvFrYsBQZgQAE7ERZReE4EkCDUAQEAhTgvDfARom4SPa5RIATeSOrevwFOuJGrqlqFtZkDxj2WjbAsQOLhTw1FY/NJCqQDXB0gZXtddNr/0yUiWojgMAQAvZHMG7HHAKPRRBIRIAAJ5GGDqSadp2VvR4LpGiVFoNbqCrlZeWxCtiFcvavkL0ukO217HyxmlCv5gWsV5h9kHWfSNn7BIrNtxUlQKBtAgQ4bWsxyotA/QLd5x31l4AtpiRgAU5q11kEOCnt5dS1NAE7YGQvhC2syfbA0QbtpJeeX6Xxs6IeAhYq6i3bL7tPpGye1D7oenDxEgIIFBSwzzL1wLGQuOAqmB0BBCIX6D7viLy6VK9hAbseS+28lgCn4R2PzbdTQB9Q3SewiwU49npqB5d2tmx7S23hTHa/7D6Rsn2xO2Rsb60pOQII1CVAgFOXNNtBoL0Cdpzgj5btbcM2lZwAp02tNWRZOagMCcdiHYG11lrLvfjFL3YTExMLBnHsd3HcK/DprJRvEChBQPuYJut9o++7Axy9xnFQCkwIIFBUwI4d9MApKsf8CKQjYMcJApx02rzJmmp/S3FcNnrgNLnXse3WCiismZ2dXVD+XhfMC2biBQRKFujV+0ab6LU/WtBIj7CSG4HVIRC5gF2YEeBE3tD/n707Om7rBqIwzDSQB5WQBhJXkFacCuJWUoHUkeOKnIEy67mmKZnkBXh3gc8PEUkTwO5/kAX2iJakh8AOAlEnGDg7IBp6NQEGztWo6r5RUamrXZXILzXMVWIXZ10CcYBtP33Tsmn7sf259Lp/RvWKxn8QQOBKAs0o/v3331+/27n9p5pXDvc2BBBYgIBeawGRE6UY99zVvinpEziJNqFQ6hNg4NTXsFIGv/766+m33357/XXhlxqqONjODZx2wfry5cvp+fm5UrpiRQCBAwnEJ/1aCJfqzYGhWRoBBJIQYOAkEWKRMOKey8CZWHBFZWJxk6TGwEkixGJhvPdP+hqKcwNnMTzSRQCBDgQYOB0gmgKByQnotSYXOFl6DJxkgowIR1EZQdWcWwIMnC0Nj48mEAcbA+doJayPQH0CDJz6GsoAgdEE9FqjCZt/SyDuuT6Bs6Uy2WNFZTJBE6bDwEkoysIhxcHGwFl4E0gdgU4EGDidQJoGgYkJ6LUmFjdhanHPZeAkFKdXSIpKL5LmeYsAA+ctMl4/gkAcbAycI+hbE4G5CDBw5tJTNgiMIKDXGkHVnG8RiHsuA+ctQhO8rqhMIGLyFBg4yQVaLLxW89qv/GXgLCa8dBEYQICBMwCqKRGYjIBeazJBk6fDwEkuUI/wFJUeFM3xHgEGznt0/N2jCTBwHk3cegjMS4CBM6+2MkOgFwG9Vi+S5rmGAAPnGkrF36OoFBewQPgMnAIiLRRiGDirfbR0IYmlisDDCDBwHobaQgiUJaDXKitdycAZOCVluy1oReU2Xt59O4FWSF5eXk7Pz8+3DzYCgc4EGDidgZoOgYUJMHAWFl/qCFxJQK91JShv60KAgdMFY+5JFJXc+swQHQNnBhXnyYGBM4+WMkHgaAIMnKMVsD4C+QnotfJrNFOEDJyZ1HwjF0XlDTBe7kaAgdMNpYk6EGDgdIBoCgQQeCUQBs7nz59PX7588UlT+wIBBH4goNf6AYkXBhJg4AyEm2VqRSWLEvPGwcCZV9uKmTFwKqomZgRyEtgaOC3CT58+5QxUVAggcBgBvdZh6JdcmIGzgOyKygIiH5xi22O+M3mwCJb/RoCB8w2FBwggsJPAH3/8cfrnn39O7RM47Q8DZydQwxGYkIBea0JRE6fEwEksTq/QFJVeJM3zFgF77C0yXj+CAAPnCOrWRGBOAmHgtOyaicPAmVNnWSGwh4B78B56xt5KgIFzK7GC71dUCopWLGR7rJhgk4fLwJlcYOkh8EACDJwHwrYUAkUJuAcXFa5o2GHg/Pnnn0UzuC/sX56enr7eN7TeKEWlnmbVIm6FxHcmq6k2b7wMnHm1lRkCjybAwHk0ceshUI+AXqueZpUjZuBUVu/K2BWVK0F5290EGDh3ozNwAIEwcF5eXvzGmAF8TYnASgQYOCupLVcE7iOg17qPm1H3EWDg3Met1ChFpZRcJYNl4JSUbdqg47fGMHCmlVhiCDyMAAPnYagthEBZAnqtstKVDJyBU1K224JWVG7j5d23E2Dg3M7MiHEEGDjj2JoZgdUIMHBWU1y+CNxOQK91OzMj7iOwPZP8DJz7GJYYpaiUkKl0kAyc0vJNFzwDZzpJJYTAYQS2l2U/6+0wGSyMQGoCeq3U8kwV3PZMYuBMJe33ySgq3/PwrD8BBk5/pma8nwAD5352RiKAwPcEtpdlBs73bDxDAIH/Cei17IRHEdieSQycR1E/YB1F5QDoiy3JwFlM8OTpMnCSCyQ8BAoR2F6WGTiFhBMqAg8koNd6IOzFl9qeSQyciTeDojKxuElSY+AkEUIYrwQYODYCAgj0IrC9LDNwelE1DwJzEdBrzaVn5my2ZxIDJ7NSO2NTVHYCNPynBBg4P0XkDQ8kwMB5IGxLITA5ge1lmYEzudjSQ+BOAnqtO8EZdjOB7ZnEwLkZX50BikodrapGysCpqtyccTNw5tRVVggcQWB7WWbgHKGANRHIT0CvlV+jWSLcnkkMnFlUvZCHonIBipe6EmDgdMVpsp0EwsDRbO0EaTgCCJy2l2U1xYZAAIFLBPRal6h4bQSB7ZnEwBlBOMmcikoSISYOoxk47c9qhWRiSUunxsApLZ/gEUhHIM44Bk46aQSEQAoCeq0UMiwRBANnCZlPJ0VlEaEPTDMutwycA0Ww9DcCDJxvKDxAAIEOBOKMY+B0gGkKBCYkoNeaUNSkKTFwkgrTOyxFpTdR850TiMstA+ecjOdHEIjDTbN1BH1rIjAfgTjjWmbOufn0lRECewnotfYSNP5aAnHHbe9f7Tz65enp6eu1oKq/T1GprmD++ONyu1ohya/MmhHG4cbAWVN/WSPQm0CccW1e51xvuuZDoD4BvVZ9DatkEHfcFu9q5xEDp8ouFWcJAnG5Xa2QlBBnwSDjcGPgLCi+lBEYQCDOuDa1c24AYFMiUJwAA6e4gIXCjztuC3m184iBU2ijCjU/gbjcrlZI8iuzZoRxuDFw1tRf1gj0JhBnXJvXOdebrvkQqE+AgVNfwyoZxB23xbvaecTAqbJLxVmCQFxuVyskJcRZMMg43Bg4C4ovZQQGEIgzrk3tnBsA2JQIFCfAwCkuYKHw447bQl7tPGLgFNqoQs1PIC63qxWS/MqsGWEcbgycNfWXNQK9CcQZ1+Z1zvWmaz4E6hNg4NTXsEoGccdt8a52HjFwquxScZYgEJfb1QpJCXEWDHLlw21BuaWMwHACcca1hZxzw3FbAIFyBBg45SQrG/DKd1wGTtltK/CMBOJy62KbUZ31Ylr5cFtPbRkjMJ5AnHFtJefceN5WQKAaAQZONcXqxrvyHZeBU3ffijwhgbjcutgmFGfBkFY+3BaUW8oIDCcQZ1xbyDk3HLcFEChHgIFTTrKyAccdd8UfE8DAKbttBZ6RQFxuXWwzqrNeTHG4tcztyfX0lzECvQnEGdfmVVN60zUfAvUJMHDqa1glg7jjMnCqKHZnnIrKneAMu5pAXG5dbK9G5o0DCcTh1pawJweCNjUCixCIM66lq6YsIro0EbiBgF7rBljeuovAX3/9dfr48eOJgbMLY/7Bikp+japHGJfbv//++/Tvv/9WT0f8ExCIPanZmkBMKSBwMIF2j/rw4cNrFGrKwWJYHoGEBPRaCUWZNCQGzqTCnqelqJwT8bw3gWiWGTi9yZrvXgKxJzVb9xI0DgEEggADJ0j4igAClwjotS5R8doIAgycEVQTzqmoJBRlspCiWWbgTCZs4XRiTzJwCosodASSEGDgJBFCGAgkJaDXSirMhGExcCYU9VJKisolKl7rSSCaZQZOT6rm2kPAntxDz1gEENgSYOBsaXiMAALnBPRa50Q8H0WAgTOKbLJ5FZVkgkwYjmZ5QlGLp2RPFhdQ+AgkIsDASSSGUBBISECvlVCUSUNi4Ewq7Hlaiso5Ec97E9As9yZqvr0E7Mm9BI1HAIEgsDVwfNI0qPiKAAJBQK8VJHwdTYCBM5pwkvkVlSRCTByGZnlicYumZk8WFU7YCCQkwMBJKIqQEEhEQK+VSIzJQ2HgTC5wpKeoBAlfRxHQLI8ia957CdiT95IzDgEEzgkwcM6JeI4AAlsCeq0tDY9HEmDgjKSbaG5FJZEYk4aiWZ5U2MJp2ZOFxRM6AskIMHCSCSIcBJIR0GslE2TicBg4E4u7TU1R2dLweAQBzfIIqubcQ8Ce3EPPWAQQ2BJg4GxpeIwAAucE9FrnRDwfRYCBM3od5LIAAALHSURBVIpssnkVlWSCTBiOZnlCUYunZE8WF1D4CCQiwMBJJIZQEEhIQK+VUJRJQ2LgTCrseVqKyjkRz3sT0Cz3Jmq+vQSi4fIbY/aSNB4BBKKeNBJqiv2AAALnBPRa50Q8H0WAgTOKbLJ5FZVkgkwYDgNnQlGLpxQN18vLy+n5+bl4NsJHAIEjCUQ9aTEwcI5UwtoI5CSg18qpy4xRMXBmVPVCTorKBShe6kogDBzNclesJttBIBoue3IHREMRQOCVQNST9oSBY1MggMA5Ab3WORHPRxFg4Iwim2xeRSWZIBOGw8CZUNTiKUXDxcApLqTwEUhAIC7MLRQGTgJBhIBAMgJ6rWSCTBxOnEefP38+ffr0aeJMf0ztl6enp68/vjznK4rKnLpmyoqBk0kNsTQCDBz7AAEEehGIC3Obj4HTi6p5EJiHgF5rHi2zZxLnEQMnu1I741NUdgI0/KcEGDg/ReQNDybAwHkwcMshMDGBuDC3FBk4EwstNQTuJKDXuhOcYTcTiPOIgXMzuloDFJVaelWMloFTUbW5Y2bgzK2v7BB4JIG4MLc1GTiPJG8tBGoQ0GvV0GmGKOM8YuDMoOY7OSgq78DxV10IMHC6YDRJRwIMnI4wTYXA4gTiwtwwMHAW3wzSR+ACAb3WBSheGkIgzqMVf8ajn4EzZEuZdFUCDJxVlc+bNwMnrzYiQ6Aagbgwt7gZONXUEy8C4wkwcMYztsL/BFa+3zJw/F+AQEcCDJyOME3VhUAccCt+xLQLQJMggMA3Agycbyg8QACBCwQYOBegeGkIgbjf+gTOELx5JlVU8mgxayQMnFmVrZtXHHAMnLoaihyBLAQYOFmUEAcCOQnotXLqMmNUcb9l4Myo7iYnRWUDw8MhBBg4Q7CadAeBaLgYODsgGooAAq8Eop60Jytemm0DBBB4n4Be630+/rYfgZUNnP8AAAD//5+7RcQAAEAASURBVO3dCawkW10/8Ho8CKsGRnBD5I/4EiQKM4gYiWQ0KIugggubIDNEUVCYyyKSIBgQFQThjbghyJ3IqiBCQEFD1AcERMWZeShxBRVlk4RVJI8H78/py2+67p27dPftqjrLp5P3pm93ddU5n9/pU1XfW933kiNHjlzTNXK7/PLLZz3d2NhopMe6ObbAFVdcMdvkmTNnus3NzbE3b3sELhI4efJkd+LEie7s2bOdue8iHg8QILCEQMwn6SX2c0vAWZRAIwLOtRopdAbdTGPt2LFjTe6LLhHgZDACNaEaAQFONaWspiNxwiXAqaakOkJgMoGYT1IDBDiTlcGGCWQrIMDJtjTVNUyAU11Jd++QSWV3F4+uT0CAsz5La1qPQJxwCXDW42ktBFoWiPkkGQhwWh4J+k5gdwHnWru7eHT9AgKc9ZtmuUaTSpZlqapREeA4Wa6qrEV3Jk64jMmiy6jxBLIQiPkkNUaAk0VJNIJAVgLOtbIqR9WNEeBUXd5550wqcwv3hhEQ4Azjaq2rC8QJlwBndUOvJEBgS+Do0aPd6dOnZz8IcIwKAgR2CjjX2ini56EEBDhDyWa2XpNKZgWpsDkCnAqLWniXBDiFF1DzCWQkIMDJqBiaQiBDAedaGRal0iYJcCot7M5umVR2ivh53QICnHWLWt9hBSLASes5fvz4YVfn9QQINCwgwGm4+LpOYAEB51oLIFlkLQICnLUw5r8Sk0r+NSq9hQKc0itYX/sFOPXVVI8ITCUgwJlK3nYJlCHgXKuMOtXQSgFODVVcoA8mlQWQLHIoAQHOofi8eACB/gmXK3AGALZKAg0J9OcT34HTUOF1lcCCAs61FoSy2KEFBDiHJixjBSaVMupUcisFOCVXr86290+4BDh11livCIwl0J9PBDhjqdsOgXIEnGuVU6vSWyrAKb2CC7bfpLIglMVWFhDgrEznhQMJ9E+4BDgDIVstgUYE+vOJAKeRousmgSUEnGstgWXRQwkIcA7FV86LTSrl1KrUlgpwSq1cve3un3AJcOqts54RGEOgP58IcMYQtw0CZQk41yqrXiW3VoBTcvWWaLtJZQksi64kIMBZic2LBhTon3AJcAaEtmoCDQj05xMBTgMF10UCSwo411oSzOIrCwhwVqYr64UmlbLqVWJrBTglVq3uNvdPuAQ4ddda7wgMLdCfTwQ4Q2tbP4HyBJxrlVezUlsswCm1cku226SyJJjFlxYQ4CxN5gUDC/RPuAQ4A2NbPYHKBfrziQCn8mLrHoEVBJxrrYDmJSsJCHBWYivvRSaV8mpWWosFOKVVrP729k+4Tp061Z07d67+TushAQKDCPTnk7Nnz3YbGxuDbMdKCRAoU8C5Vpl1K7HVcc7V4i8TLjly5Mg1JRZtlTabVFZR85plBGIycWC7jJplhxTon3AJcIaUtm4C9Qv05xP7ufrrrYcElhVwrrWsmOVXFYhzLgHOqoKFvM6kUkihCm5mTCYObAsuYmVN759wCXAqK67uEJhAwH5uAnSbJFCIgHOtQgpVQTNjXyTAqaCY+3XBpLKfjufWIZAmkxTenD9/vtvc3FzHKq2DwKEFYicnwDk0pRUQaF4g5hO/qGh+KAAgcJGAc62LSDwwkEDsi1o8tvURqoEGldW2KZAmkxaT4DarXU6vW97JlVMlLSVQhkDMJwKcMuqllQTGFBDgjKnd9rZiXyTAqXwcmFQqL7DuESCwq0DLO7ldQTxIgMDKAjGfCHBWJvRCAtUKONeqtrTZdSz2RQKc7Eqz3gaZVNbraW0ECJQh0PJOrowKaSWBcgRiPhHglFMzLSUwloBzrbGkbSf2RQKcyseCSaXyAuseAQK7CrS8k9sVxIMECKwsEPOJAGdlQi8kUK2Ac61qS5tdx2JfJMDJrjTrbZBJZb2e1kaAQBkCsZPz/Uxl1EsrCeQsEPOJACfnKmkbgWkEnGtN497iVmNfJMCpvPomlcoLrHsECOwqEDs5Ac6uPB4kQGAJgZhPBDhLoFmUQCMCzrUaKXQG3Yx9kQAng2IM2QSTypC61k2AQK4CsZMT4ORaIe0iUI5AzCcCnHJqpqUExhJwrjWWtO3EvkiAU/lYMKlUXmDdI0BgV4HYyQlwduXxIAECSwjEfCLAWQLNogQaEXCu1UihM+hm7IsEOBkUY8gmmFSG1LVuAgRyFUhz37FjxzoBTq4V0i4C5QjEQbMAp5yaaSmBsQSca40lbTuxLxLgVD4WTCqVF1j3CBDYVUCAsyuLBwkQWEEgDpoFOCvgeQmBygWca1Ve4Iy6F/siAU5GRRmiKSaVIVQPXufRo0cPXugQS6QrC1q9pQPoRW/nzp1bdFHLVSYgwKmsoLpDYEKBmE8EOBMWwaYJZCrgXCvTwlTYLAFOhUXdrUsmld1U1v9YBDYnTpyYfWxj/VuwxsMKpAPv8+fPz1azubl52NV5feYCccLlI1SZF0rzCBQgEPOJAKeAYmkigZEFnGuNDN7w5gQ4jRTfpDJsoU+ePNml0Ga/W1wxkk4kh7oNcUXO7W9/+6Gau+96I2TZa6Hw3Ov59HjfI/Wj/3O8LuohzAmRuv51wlVXPfWGwJQC5pMp9W2bQN4CzrXyrk9NrRPg1FTNffpiUtkH5xBP7RfcpIAhwgEf4TkE8gAvTXVLt52hW6qXIGcA8AlX6YRrQnybJlCZQMwnqVvHjx+vrHe6Q4DAYQScax1Gz2uXERDgLKNV8LImlfUWL31UKp3877yiI0Ibgc16vYdc225hjiBnSPFx1x0nXOm9ubGxMe7GbY0AgaoEYj5JnRLgVFVanSFwaAHnWocmtIIFBQQ4C0KVvphJZb0VjDdOrDWd8KcTRMFNiJT5b/+KqtpDnPi+pt0qtTOY7C+z6Efq9ltHf31D37/mmmu6Sy65pIt/D7u99D5f9nbQxwF3W9/O7ZhbdlPyGIFxBQQ443rbGoGSBJxrlVStstsa56H+ClXZdTyw9SaVA4kWXqB/AJdOstKJvpOrhfmyX7Af4qTG1jI5xlVjqU+5hCupLWPd1hXgjNXe/baT5p0IhXzkbz8pzxFYr0B//+8KnPXaWhuB0gVifjA3lF7JvNufjudPnz49a2Qt5yjLiF9y5MiRa5Z5QcnLCnDWU72YnNPaar9CYz1i5a4lap1Olkv+6M3OQGpnReJKjxQIxP20TC2hZPS/tDr2r5DqB267fRl3movSTZgzY/A/AoMJxH4hbcBJ2mDMVkygSIGYH8wNRZavmEYLcAQ4xQzWHBoaJ4KpLcKbHCoybBv6E2SJ9U7t3+97mpJeLSHNfiMh6lhagLNfn9JzaT5Kt1Tj/q3Esdpvv/sEchaIE7TURidpOVdK2wiMLxDzg7lhfPuWthjHtanPrsCpvPJpUkm3kq8kmLpE8XlDJ0hTV2K87fdDu5ImyTiI6EulACON3RZCm36/0/0IO2q9QqU/TqPv5qmQ8C+B9QnEsVS6YrHW+WR9WtZEoC2BOPYS4LRV97F7K8BxBc7YY67Y7cUJkpOiYku4csNjh1zKFRwxVqPDacymtrcY3IRBK//uVnsnma1Uf5x+pgPHnbf+R/x2Prfsz4t+Sfp+643vh9pvmdKeS3N4zrfdxoC5J+eKadsQAnG8KMAZQtc6Q6Af4LQ41nwHTowE/x4oEFfftPhGORCngQWi/rlfhbPzBD739jYwdEbv4s4xUErwODqUDR4okA4Sd/sY5oEvtACBLwqk+Se+X80vEQyL2gUEOLVXOI/+CXBcgZPHSMy8FXFC5OqbzAs1YPNip5zzyXCM08SQczsHLJNVf1GgPxbSQ+YuQ2NRgd1CmzSfpFuciC+6rrTcbldm7Pf6Ra/AWXa9+22zlueiTgf1Z5ErlBZdV2wr6rHbl6zHMuahkPBvrQJxrOiXvbVWOI9+CXAEOHmMxMxbESdDJuTMCzVg80qYLOMqIQfJAw6EglYd81Y02dVYIeHfvQTi5CM9n07g01ySbq1fOZHm/8PcWvRL80+67fyS9fSYfVRScKtRIOZQ5ws1VjefPpVwTjKklo9QDalb0brTibEDjooKumJXIiDJ8UQ4TtbTSZcvKl+xwBW+LA4mU9eMjQoLvKYu9Q8GI7hpMXRYE6fV7BCI/VP/YcdUfQ33axGIfa4Ap5aK5tmP/j67xbEmwMlzXGbVqjjwcLCRVVkmaUzsmHM8EY5wqcWJfJLBUNBGY9ymJpvHCircSE2NfZzxMRJ4w5vpj7XEkOMvQxouj66vQSD2t47F1oBpFXsKCHB8hGrPweGJLYE44DAZGxExYeYW4MQYdXJujO4mEOM2njOXhYR/Y2y46sZYGEsg9lexPSFOSPi3BgEBTg1VzL8Pse9OLW3xmM4VOPmP0clb6MqGyUuQTQNynTB9xC+bIZJtQ+KgMjXQCVO2ZRq9YTEuWjwAHB3bBi8I9EOc3H4hcqGR7hBYQcCcugKalywtkOv5yNIdWfEFApwV4Vp6WTo5doDRUsX372tugV4cCDsp379urT/b39mbz1ofDVv9j7nDlXvGwxQCcaKbtm3/NUUFbHMIgRjXQvEhdK0zBPrHdC2ONQFOjAT/7ing6oY9aZp8ItcAp8UJvMkBeIhOx9gV4BwCsZKXCm8qKWTh3YiTXXNS4YXU/AsCMaYdk10gcWcAAQGO78AZYFjVtUoBTl31PGxvcts5G5+HrWg7r4+xm3rsN97t1H23nsZYcPXNbjoeG0ugfxJiThpL3XaGFIi5VYAzpLJ19+fOFseaK3C8B/YViDeIg9x9mZp6Mqeds9+iNzX0Dt3ZmM/SipwsHZqz6BXE1VgtHvgVXbgKGx/7VHNShcVtsEsxns2tDRZ/xC73j+daHGsCnBEHW4mbijeIA4sSqzdMm3PaOefUlmG0rXXdAjFmhNLrli1nfYLfcmrVQkvjOMvHqFqodv19jH1siyfV9Vc3nx7GvJla1OJYE+DkMxazbEm8QQQ4WZZnkkbFyU8OE2Y6UEi3jY2NSSxstDyBOLgU4JRXu3W1OOYwY2BdotZzWIG4Isyx1mElvX5qgdjH5nCMOLWF7Q8nEOenaQstjjUBznBjq4o1xxukxTdHFQUcoBNx8pPDmEgHvX5rOUCRK15ljF8n7xUX+YCuxclyDnPYAU31dCMCcdIrwGmk4BV3M8ay+bXiImfQtTg/TU1pcawJcDIYhDk3IU52Wnxz5FyXKduW05hIJ2JOxKccDeVtO3b6xk15tVtXiwW/65K0nnUJxH5VgLMuUeuZSkCAM5V8W9uNOTP1usVzVAFOW+N96d7GG6TFN8fSWI28IMbE1AeaTsQbGXBr7maMG1durRm2kNVF/QV4hRSskWbGuJx6v9oIt24OKCDAGRDXqi8IxLlIeqDFc1QBzoWh4M5uAvEGafHNsZuHx7ouxsTUB5oOeI3GVQVcgbGqXPmvi3lDgFN+LWvqQYzLqferNZnqyzQCApxp3FvbapyLpH63eI4qwGltxC/Z33iDtPjmWJKqmcVjTEx9oOmAt5kht/aOpgPMdPPl12unzX6FMW8IcLIvVXMN9JHg5kpeZYcFOFWWNbtOxblIaliL56gCnOyGZF4NijdIi2+OvCqRT2tiTAhw8qmJliwnIMBZzqumpSPAmXr+qslUX9YjIMBZj6O1TCsgwJnWv5Wtx7lI6m+L56gCnFZG+or9jDdIi2+OFcmqf1mMialPgJyIVT/UBuugj1ANRpv9inOZv7KH0sDRBQQ4o5Pb4AACApwBUK3yIoHYl6cnWjxHFeBcNCQ80BeIN0iLb46+g/tzgRgTU38EQYAzr4l7ywk4UVrOq6alY/6yT6upqnX0xbxURx1b74UAp/URME7/Y1+ettbi/lyAM844K3Yr8QZp8c1RbNEGbniMCQHOwNBWP5iAE6XBaLNfccxf9mnZl6q5BpqXmit5lR0W4FRZ1uw6FfvyVv+iqAAnuyGZV4PiDeJgN6+6TNmaGBMCnCmrYNuHEXCidBi9sl/r5KLs+tXc+jQvtXoyUnNdW+ubOba1ik/T3zgXaXXOFOBMM+6K2Wq8QQQ4xZRs8IbGmBDgDE5tAwMJCHAGgi1gtU4uCihSo00U4DRa+Mq6bY6trKCZdifORQQ4mRZonc1Kk0q6+dOxi6vGG0SAs7hZ7UvGmBDg1F7pevsnwKm3tgf1LNU+3ezTDpLy/NgCApyxxW1vCAEBzhCq1rlTIM5FBDg7ZSr8WYCzfFHjDeJgd3m7Wl8RY0KAU2uF6++XAKf+Gu/VQwHOXjIen1pAgDN1BWx/HQICnHUoWsdBAnEuIsA5SKqC5wU4yxcx3iAtBziXXHJJ99Vf/dXdZZdd1t3kJjfp3vve93b//u//3n3sYx9bHrSCV8SYEOBUUMwGuxB/vWzq8dsgfRZdFuBkUQaN2EVAgLMLioeKExDgFFeyIhsc5yICnCLLt1yjBTjLeaWl4w3SYoCTgpuHPOQh3YMe9KDu+te//kV4//M//9P98i//cvfOd77zoudqfiDGxNQnwHEifurUqe7cuXM1k+vbGgVi3Ew9ftfYJataQkCAswRWb9FLL720u+ENbzh75FOf+lT3+c9/vvfs9rtpf3md61ynu/rqq7tPf/rT25/0054CApw9aTxRkIAAp6BiFdzUOBcR4BRcxEWbLsBZVGq+XLxBWgtw0sHn4x73uO6e97znDCNdbfOud72r+8hHPtLd6la36tJJYNx++7d/u3vFK17RXXPNNfFQ1f/GmMjhBDgd8Apwqh5ua++cAGftpMWsMGqfGtzaPu2wRbr1rW/dvehFL5qt5glPeEL3jne8Y89VpuXS8m9961u7Jz3pSXsu54ntAgKc7R5+KlNAgFNm3UprdZyLCHBKq9wK7RXgLI8Wb5DWDnaf+MQnXghvfuu3fqv7gz/4g22/cbzpTW86OzC9wx3uMEP9pV/6pe5P//RPlwcu8BUxJnIJcHJox9RlvO51r9ul/6666qruM5/5zK7NSaFkXEm233K7vriiB+Mk3ripqKgLdiVqnxZvbZ+2ING+i/3e7/1ed8tb3rJ7wxve0D3jGc/Yddlb3OIW3Ute8pLZc095ylO6uOJp14U9uE1AgLONww+FCghwCi1cYc2OcxEBTmGFW6W5Apzl1eIN0tLB7s1vfvPuZS972Qzr2c9+dve6171uV7hrXetaXQp3bnOb23Qf+MAHuh/5kR/pPve5z+26bE0PxpjI4QQ4HfDm0I6p6/uwhz2se+hDH7rnidWNb3zj7jnPec7st+KprQf9Bn3q/gy5/TiJN26GVM5z3VH71LqW9mnrqsYDHvCA7hGPeMRsdd/93d89C4x3rjvtBx/+8Id3//d//9fd5z732TNQ3vk6P3ezsKvVkxH1r0dAgFNPLXPuSZyLtDpnXnLkyJE2PvfxhVEowFn+rRhvkJYOdtNHcn7gB36ge9/73jc7Kd4vlPmmb/qm7td//ddnsI997GOb+D6cGBM5nAALcLbe0/sFOMKb7fNenMTnMH63t8xPQwtE7dN2Wtqnrcv1y7/8y7tXvvKVs9Wlq1Tf/va3X7Tq+PjUa1/72llofNECHthTwBU4e9J4oiABAU5BxSq4qXEuIsApuIiLNl2As6jUfLl4g7R0sPv85z9/dlVNulz8d3/3d+cYe9xLB6pxkpzu136LMZHDCbAAZ2u07RXgxLhM30eRbhsbG13a2bV8i5P4HMZvy3WYou9R+7TtlvZp67T+1V/91e6Od7xj92d/9mfdL/7iL25bdf/jU4961KO6K6+8ctvzfthfQICzv49nyxAQ4JRRp9JbGeciApzSK7lA+wU4CyDtWCTeIC0d7L7xjW+cfVfIr/zKr3R//Md/vEPk4h9Pnz49+1Ljl7/85V36QuPabzEmcjgBFuBsjbbdApyd4c1P//RPz76Iu/bxeVD/4iTel18fJFXf81H71LOW9mnrrOTd7na3C19MfPe7333bR6Ti41PpLzTe73732/a9cetsQ63rcuJba2Xb6pdx3Fa9p+ptnIsIcKaqwIjbFeAsjx1vkFYOdtMXwabfLKbbot8T8vSnP727y13u0r3mNa/pnvvc5y6PXNgrYkwIcPIp3M4Apx/epO+iSB/ve/e7351PgydsSYxfAc6ERZho0wKcw8Pf4AY3mH3XVlpT+gtT6S9NxS0+PrW5udml/YPbcgJOfJfzsnSeAsZxnnWprVUxzgQ4tVV2l/4IcHZBOeChONlpJcBJHHEFTro8PMKc/ZjioDV99Cq+/Hi/5Ut/LsaEACefSvYDnHQVWHxhcQpv0kcZ/uVf/iWfxk7ckhi/ApyJCzHB5qP2adMt7dPWTZ2Cm3Qlzpve9KbuF37hF2ar73986sEPfvDsO+TWvd3a1xcnJMZm7ZWuu3/Gcd31zaV3Mc4EOLlUZMB2CHCWx40D3pYOKNJflrrtbW/bLfJbxPSnmdNBbLo99alP7f78z/98eeTCXhFjQoCTT+EiwPnrv/7r7su+7Msu/LWp9NfRUr1SkOO2JZDT+FWTcQWi9mmrLe3T1q38Ld/yLV36C43pFh+jetCDHtT9xE/8RPeP//iPs3/Xvc0W1hcnJMZmC9Wut4/Gcb21zalnMc4EODlVZaC2CHCWh40D3pYOKH7mZ36mu/e9773nnwa/7LLLuksvvXR2oHrf+9539sWwSTb9ydSPfvSjyyMX9ooYEwKcfAoXAU60KAU217/+9Wc//smf/En3zGc+M55q/t+cxm/zxRgZIGqfNtvSPm3dzGn/9+pXv3r25f1PfvKTuze/+c1dXImarv5r4cv8122a1ucYdQhV6xxbIE6szbFjy7e1vRhnApwG6m7nuHyR44C3pYk4/cWedDCabmnM/NEf/dEFuBvd6EbdS1/60tmB62/+5m/Orm5IJ8rpr1Wlv1rVwi3GhAAnn2r3A5z0BaKPfvSju3vc4x7dQx/60Fkjn/KUp3TpC5/dutl79sSJE10O41c9xhXwHTjr8/7Jn/zJ7oEPfGD3F3/xF7P930te8pLZyr/v+76v+/jHP76+DTW0JseoDRW74q7GMWJL5w0VlzPbrglwjhy5JtvqrLlhdo7Lg7Y6EacT3rve9a4zsBe/+MWzk72rr766u+SSS7p01U36/oy4fexjH+vuf//7b/trHPFcjf/GpJnDCbC/QrU1wiLASeHNIx7xiC79e+1rX3v2V9HSFWPpipwf/dEf7T784Q/XOCSX6lPMaTmM36UabuFDCwhwDk14YQVpXnnhC184+zmFN+l7b97ylrd0P/dzP3dhGXeWE3CMupyXpfMUiH2sACfP+tTSqjgXcQVOLRXdpx92jvvg7PFUqxPxTW5yky6FOHe4wx0uyPz93/999/73v79LV+Hc+c53vvB4+p6RjY2N7oMf/OCFx2q+E5NmDifAApytkRYBzhve8IbuGc94xoXh97Vf+7VdCiDT7corr5yN08997nMXnm/xTsxpOYzfFv2n7LMAZ7366arTW97ylhdWmsKbFOK4rSbgGHU1N6/KSyD2sQKcvOpSW2viXESAU1tld+mPneMuKAc81PJEfK1rXWt2ifhDHvKQC98n0ud629ve1h05cqS7zW1uM7vCIX13zrve9a7+IlXej0kzh7/iI8DZGmJ7BTjp2f73NL3gBS/o4qMOVQ7OBToVc5oAZwGsyhYR4Ky3oOnK00c+8pGzlaar/NLHp6666qr1bqShtTlGbajYFXc19rECnIqLnEHX4lxEgJNBMYZugp3j8sIm4m72samv+Iqv6G51q1vNrr75yEc+MvsTqenf9DGVhz/84bMD13QSna7Qqf0Wk+bUAU6cjDkR77r9ApwURKYvMb7Tne40G5rpI1bvfve7ax+me/Yv5jTjZk+iap+IOSN10MnF4ct8s5vdrHvVq141W9FrXvOa7rnPfe7hV9rwGhyjNlz8iroe+1hzbEVFzbArcS7S6rHcJV+4gsB34GQ4MHNpkol4sUp8yZd8SffJT35ysYULXyomTQFOPoXcL8BJrbzpTW86u/ImfeF2+shfWv7Tn/50Ph0YsSUxp7W60x+ROrtNCXCyK4kG9QQEOD0Md4sViH2sAKfYEhbR8DgXafVYToBTxDCdrpEm4unsc91yTJoCnHwqlP6qUnqv7vcnw9PB1NOe9rRZo1v+bXnMaa3u9PMZteO3RIAzvrktLi4gwFncypL5CsQ+VoCTb41qaFmci7R6LCfAqWEUD9gHE/GAuIWuOiZNAU6hBWy82TGntbrTb7z8XfrerHRzctH6SMiv/wKc/GqiRcsLxD7WHLu8nVcsLhDnIq0eywlwFh8rTS5pIm6y7Pt2OiZNAc6+TJ7MVCDmtFZ3+pmWZbRmCXBGo7ahJQUEOEuCWTxLgdjHCnCyLE81jYpzkVaP5QQ41QzlYTpiIh7GteS1xqQpwCm5iu22Pea0Vnf67VZ+q+cCnNZHQL79F+DkWxstW1wg9rECnMXNLLm8QJyLtHosJ8BZfsw09YqYiKc+WW8KPfPOxqQ59c45vs+i1ck782GSbfNiTjNusi3RoA0T4AzKa+WHEBDgHALPS7MRiH3s1MeI2YBoyCACcS7S6rGcAGeQYVXPSmMiFuDUU9PD9iQmzal3zgKcw1ayzdfHnNbqTr/Nqs97ncv8NW+RewS2BAQ4RkINArGPnfoYsQZLfdhbIPblrR7LCXD2Hhue+YJATMQCHMMhBGLSnHrnLMCJivh3GYGY01rd6S9jVeOyucxfNdrq0+EEBDiH8/PqPARiHzv1MWIeGloxlEDsy1s9lhPgDDWyKllvTMQCnEoKuoZuxKQ59c5ZgLOGYja4CuOmwaL3upzL/NVrkrsEZgJpbJ4/f77b3NwkQqBYAecNxZauqIbHvlyAU1TZVmtsKna6bWxsrLaCBl9lIm6w6Ad0OSZNAc4BUJ7OUkCAk2VZRmtU7NOmnr9G67ANFSOQvp+p1ZORYoqkoQcKxBzrF78HUlngEAJxLtLqnOkKnEMMnhZeaiJuocrL9TEmzalPgOJE3EHCcvVrfekYN63u9Fuvf+zTpp6/Wq+D/l8sIMC52MQj5QnEHOvYrLzaldTiOBdp9VhOgFPSaJ2grSbiCdAz32SMialPgOJE3EFC5gMms+bFuGl1p59ZOUZvTtTfvDE6vQ0eICDAOQDI00UIxDGiObaIchXbyPiLkq0eywlwih264zTcRDyOc0lbiTEhwCmpatraF0g7/rNnz/o4bR+lkfsCnEYKXWA3BTgFFk2TLxKIY0QBzkU0HlijgADnyJFr1uiZ9arS5Vbp5jtwFi+Tg93FrVpZMnbOApxWKl5fPwU49dV00R7FPq3V39ot6mS58QUEOOOb2+L6BeIYUYCzfltrnAsIcAQ489Hg3kUCcbBrIr6IptkHYucswGl2CBTfcQFO8SU8VAfU/1B8XjyAgGOtAVCtchKBOEZ03jAJfzMbFeAIcJoZ7Kt01EHFKmp1vyZ2zgKcuutcc++cwNdc3YP7pv4HG1liXIHYrzrpHdfd1tYvYCyv39QaLxYQ4AhwLh4VHrkgIMC5QOHOFwVi5yzAMSRKFfBx2lIrt552x4Hf1HPYenpjLTUI5LJfrcFSH6YViLEsjJy2DrVvPfbjrX4c2pcY1z7CD9k/Ac4hASt8eeycpz75MTYrHFwjdUmAMxJ0ppuJPz/qBCPTAjXYrFz2qw3S6/KaBWIsm1/XDGt12wQEOK7A2TYg/LBdIE6SW004t2v4KQnEyY8Ax3goVSDt+P0VqlKrd/h2x37NGDi8pTWsRyDNSY6z1mNpLdMKCHCm9W9l6wIcAU4rY32lfjrQXYmt6hflcvVCjE2/5al6uA3SOSdLg7AWtdI4+DN/FFW2KhvrhLfKsjbbKeO52dKP2vHYh7cafPsI1ajDrbyNxUmy31SWV7uhWpxbgNPq5D1UfVtYrwCnhSrv38e4ktC+bX8nzw4vkMs+dfie2kILAgKcFqo8fR8FOI1dgXPs2LFu6o9+TD/sF29BBDjpFdwWd6t5yVwONmNsOgGrebStv28xbgR/67ctaY0xDlKbXYVTUuXqamuMQ/NRXXVtuTcCnJarP17fI8Bpdf/d3BU4Apzl31zxm8pW3yTLi9X9ilyuXogDXwFO3eNt3b2Lg0snTOuWLW99sW8zh5RXu1paHCchfkFWS0X1I/axzhmMhSEFYu5sdZwJcIYcXZWs20FuJYVcQzdy2zHHBO7gdw3FbWQVMYYFOI0U/IBuxv7NeDgAytNrFzAXrZ3UCjMQiHHd6ol1BiVooglx/N/qOBPgNDHMD9fJuNIhrcWJ8uEsS3917JhzGQetT+Clj6cp2h9juNWd/hTmOW+zv38T4uRcqbraFvOQMVdXXfWm62Js28caDUMKtH78L8AZcnRVtO7W3ygVlfJQXUnjIKcDzvjtuY9AHKqsTb045rJcQsim8DPtbJxwpOblNL9lyqVZhxSI8WasHRLSy7MUiPEtwMmyPNU0Ko7lWh1nTQU4Mak4cF/+/Rt2TpSXt6vlFTEGcjrojN+eG5e1jLJh+5HjGB62x9a+qECMjbR8TnPcou23XP4CaX914sSJLn0Xo31W/vXSwtUEYi5t9cR6NTWvWlZAgNPQX6GKSUWAs+zbZGv5uNrBpLyaX+mviskyt/dPtMu4LH2EDd/+2Ac4QR/eutQtxH4utd84KbWKebU7BTcptEnhTboZVzMG/6tUIPazjskqLXAm3Wr92N8VOJkMxBKa4WqHEqo0TBtjh5zjgWeccPmN5jC1r2mtre/wa6rlkH2J+S62kea9dEtzzLlz52b3/Y/AQQL9K27Ssmn8pLFkDB0k5/mSBWL+FOCUXMX829768ZwAJ/8xmlULnSxnVY7RGhMTZW5X3ySACBbT/Rzbl9rlNr1AHFSmlhgn09ejhBakMZNuceVEv83pZPz8+fP9hxa6n16X221dgUKai0u7pStj1nG7/e1vf2E1O9cpuLlA404DArGvFeA0UOwJuxjnJa2OMwHOhIOv1E1HiJPj1Rilmubc7hLqHW1MB8obGxs5c2rbRAIxRsxbExWg8M1GmJO6ESfrO0/UC++i5h9SYGc452qbQ4J6eZECApwiy1ZcowU4vgOnuEGbQ4OdDOVQheHbEHXOPRjpX4XjBH34cVHaFuKA0tgorXJ1tPcwV6asIySKwOmwmutoy2HbsOrrd4Yre61nt6uq9nrtuq5c2qstHidQokDsb1u9MqLEmpXW5v4xf6vjzBU4pY3ajNobk7STooyKsqampMkxfWwgHbDnHt5El2M8pp9bndDDwr9zgf648NGpuYt7BIYSSL8ZNQcPpWu9BPIWiH2uOSDvOpXcOgFO1wlwSh7BGbQ9JurUFEFOBgVZQxP6E2NpNS3liqE1lMkqFhAoeSwv0D2LEMhOIC5rL23fkR2kBhEoVCDOCwQ4hRawgGb3j+1aHWcCnAIGau5NTG+kuFojtTUduKWrNlxenHvltrdvtzpubm5uX6iAn+IEIjXVSUQBBRuoiXbwA8FaLYE9BOLELT1t7t0DycMEKheIeaDVE+vKy5tF9xzfuQIni4FYSyNi0u73Jx3ECXP6InndT5Ng+phU+o6E+H6DVK9Ut1IDuFqCqLxGSlmt6c9FDiLLqp3WlivQf9+V8tHbcrW1nECeAjEP2PfmWZ8aWiXAEeDUMI6z60OavNMtXZXTv6UDuviCwHQ/3VJIkN6I+90iWNhvmZyfi74O3cbdApfdbHcGNtGu1M6Sg5voR/wbBxHp59SvdCvxiqJZw/3vQIE01tPYjnmntvF8IIAFCEwo0J9voxlO4ELCvwTaEYi5wPu/nZqP3VMBjgBn7DHX3PYizIm/glF6GFNTAdMJbgrU0r+7hT819DUOJPp9Eeb0Ncq+n3biEdjE3CK4KbumWl+mwG5zbXovbmxslNkhrSZAYCWBmAsEOCvxedECAgIcAc4Cw8QiQwjEb8tj3elAb4jbIlf47LXde97znt097nGP2dNpR7TILU4iF1l2jGX2cq01sNnLNA4odj6ffOKqsPRceC07btZR9wg5d7ZxqJ/7/V73NsLxsOvt1yGMwyl+jm2kbaZwrrWxHf33L4EpBfrfPdZvh5O4vob7BOoXiJNr7/36az1VD2OMpe23Os58ifFUo892sxfoH5D688PZl2uhBkZw2P/On4VeaKEsBYQ2WZZFoxoT6Afk6T3ZD1dTqOqjq40NCN1tWiBOrls9sW66+CN1PsZY2lyr40yAM9Jgs5myBPoHpKnlApyy6rdoa9NOYOjboleErLMt/ROoRfsXV7Ysuvy6l9vriqCdV/Ms6rnu9lkfAQK7C8QvO1JYszMcT+9fH6Pa3c2jBGoUiJPrVk+sa6xpbn2KMZba1eo4E+DkNiq1JwuBOCCNxrQ6QUT//ZuvQISNxmi+NdIyArUKxPyT+rdbgJMeNzclBTcCbQjEybX3fRv1nqKXMcbStlsdZwKcKUaebWYtEAek/UvB/RYx65I13bgIG43RpoeBzhOYRODyyy+/8JGpdKVq/JwOqk+fPj1rk7lpktLYKIFJBOLkutUT60nQG9tojLHU7VY/ISHAaWzQ6+7BAnFCnH6bGH/hxgHowW6WGF8gwsbYcqs7sui/fwkQGFegv79M33UTAU6ai+K51CJz07h1sTUCUwnEybUAZ6oK1L/dGGOpp63uWwQ49Y9zPVxCoH9C3P8NYlqFndESkBYdRaB/gpQ2mEJHXxg6Cr2NEGheYOf+Mn0/VT/AifsJyv6z+eECoBGBOLn2nm+k4BN0M8ZY2rQAZ4ICjL3JONhotdhje5e4vRgj6UQ4XXUTl4CnvrgKp8SK1tvmGKv9HhqjfQ33CRAYUqAfIMdxVYQ26ef+Qba5achKWDeBfATifS/AyacmtbUkxljqV+x7auvjQf1xBc5BQp5vSiAOSHcefAZCqxNF9N+/+QjEWN3ZIgdNO0X8TIDAEAIxB/Wv/OsHOGmb8XO6b/+ZFNwI1C0QJ9eORequ85S9izGW2tDqfkWAM+UItO2sBOKKhvhNYX+CSI+lP81sh5RVyZptTIzV3QBi/O72nMcIECCwDoH+HNQ/gI7AJh7r70ftP9chbx0E8haI97z3e951Krl1McZSH2JfU3J/Vmm7AGcVNa+pUmDnbxP7E0TaEaWPUzk5rrL0xXWqf/KUfvudvmw7/k2dceBUXEk1mEBRAjEH9a++SR3YGeD0HzMvFVVijSWwkkAcO3u/r8TnRQsIxBhLiwpwFgArfZE44Gi12KXXb8j2x9hI24jx0Z8gIsDpPz9ke6ybwH4CETamQPH8+fOzACeN0RTkpCvFdp5U7bcuzxEgQGBZgZiDYn8Zr98twIl9qV+AhJJ/CdQrEO93AU69NZ66ZzHGUjt27oOmbttY23cFzljStpO1QAQ4/RPfnRNEHJjaKWVdyuobF2M1dTSN13RLwU0/wHGiNGPxPwIEBhJIAU5/fxmbSfvJdNvY2IiHZv/G/rPVg+1tGH4gULFAHDs7Vq64yBN3rX8c3Oo+RYAz8SC0+TwE4reJ/QPS2AmlFqYJIn52cpxHzVptRYzV1P90gJSuuIkAJz0WfznNwVPScCNAYEyBvQKc1Ia0D01/atyNAIF6BeJY2TFIvTWeumcCnK4T4Ew9Cm1/coHLLruse+ELXzhrRz/JjZ1QeiIej98i2jFNXrYmG9DfacW4jMdiTMYYFTQ2OUR0msCkAvsFOJM2zMYJEBhFII6d45hklI3aSFMCcdybOh3nZ00BfKGzApzWKq6/Fwnc61736p7whCdcdDl47ITSC2KCiMecHF/E6IERBPo7rbhaLB6LgyUBzgiFsAkCBHYVEODsyuJBAs0IxHFyHJM003EdHU0gjnvTBuP8bLSNZ7IhAU4mhdCM6QSWCXBSK+ME2c5pupq1uuX+x6dipxU7shiPcfCUjNJj73nPe7pPfOITrZLpNwECIwoIcEbEtikCGQrEMUgck2TYRE0qXCCOe1M34li48C4t3XwBztJkXlCbQHyEauckEDuh1N/+c/F4XAFRm4f+5CnQ32H1x1483j9Y6oeMApw866lVBGoUEODUWFV9IrC4QBwj949JFn+1JQkcLBDHvWnJ/vnZwa+sZwkBTj211JNDCKQdzs4vV4ydUFptqxPEIUi9dM0Ce+2w4vH+wVKM3fRRvxe84AXdP/zDP6y5NVZHgACBiwUEOBebeIRASwJx/NH/RVNL/dfX4QXiuDdtqdXzMwHO8OPMFgoViJ1Qan6rE0Shpauy2XFVzc6DotiR9QOcBJA+biXAqXIo6BSBbAUEONmWRsMIjCIQx847j1VG2biNNCEQx72ps62enwlwmhjqOrmKQOyE0mtbnSBWcfOaYQRSILPbAVEEOzsDnNjBPfGJT+ze/va3D9MoayVAgEBPIILjjY2N3qPuEiDQikAcO+92vNKKgX4OKxDHt2krrZ6fCXCGHWPWXrBA7IRSF1qdIAouX5VNT2Ny50f99gpwEkBa3nfgVDkUdIpAlgICnCzLolEERhOIY2cBzmjkzW1IgOPPiDc36HV4cYHYCaVXCHAWd7PkuAL7BTjjtsTWCBBoXUCA0/oI0P/WBeLYWYDT+kgYrv8CHAHOcKPLmosXiJ1Q6ogAp/hyVtsBAU61pdUxAsUJCHCKK5kGE1irQBw7C3DWymplPQEBjgCnNxzcJbBdIHZC6VEBznYbP+UjIMDJpxZaQqB1AQFO6yNA/1sXiGNnAU7rI2G4/gtwBDjDjS5rLl4gdkKpIwKc4stZbQcEONWWVscIFCcgwCmuZBpMYK0CcewswFkrq5X1BAQ4ApzecHCXwHaB2AmlR3f+hZ/tS/qJwHQCApzp7G2ZAIHtAgKc7R5+ItCaQBw7C3Baq/x4/Y0A5+zZs12rf/HQX6Eab7zZUmECsRNKzRbgFFa8hporwGmo2LpKIHMBAU7mBdI8AgMLxLGzAGdg6IZXL8BxBU7Dw1/XDxKInVBaToBzkJbnpxIQ4Ewlb7sECOwUEODsFPEzgbYE4thZgNNW3cfsrQBHgDPmeLOtAgXSwWi6CXAKLF4jTRbgNFJo3SSQuUCcuLV8WXvmJdI8AoMLxDwgwBmcutkNCHAEOM0Ofh1fTECAs5iTpaYTEOBMZ2/LBAjMBeLETYAzN3GPQGsCMQ8IcFqr/Hj9FeAIcMYbbbZUpIAAp8iyNdVoAU5T5dZZAtkKxImbACfbEmkYgcEFYh4Q4AxO3ewGBDgCnGYHv44vJiDAWczJUtMJCHCms7dlAgTmAnHiJsCZm7hHoDWBmAcEOK1Vfrz+xnFvy/saf4VqvPFmSwUKCHAKLFpjTY4dme9paqzwuksgM4E4cWv5oDqzkmgOgUkE0rGzAGcS+iY2Gse9Le9rBDhNDHWdXFVAgLOqnNeNJRA7MgHOWOK2Q4DAbgICnN1UPEagPQEBTns1H7PHcdwrwBlTfcJtxWfmjh8/PmErbLokAQFOSdVqs62xIxPgtFl/vSaQi4AAJ5dKaAeBaQUEONP61771OO4V4NRe6S/2T4DTSKHX2E0BzhoxrWoQgdiRCXAG4bVSAgQWFBDgLAhlMQKVCwhwKi/wxN2L414BzsSFGGvzApyxpOvZjgCnnlrW2pPYkQlwaq2wfhEoQyCOsVo+qC6jUlpJYFgBAc6wvq2vPY57W97X+A6c1t8F+r+vgABnXx5PZiAQOzIBTgbF0AQCDQsIcBouvq4T6AkIcHoY7q5dII57BThrp81zhXFw4Ttw8qxPjq0S4ORYFW3qC8SOTIDTV3GfAIGxBeIYq+WD6rHNbY9AjgICnByrUk+b4ri35X2NK3DqGc96MoCAAGcAVKtcq0DsyAQ4a2W1MgIElhQQ4CwJZnEClQoIcCotbCbdiuNeAU4mBRm6GXFw4QqcoaXrWb8Ap55a1tqT2JEJcGqtsH4RKEMgjrFaPqguo1JaSWBYAQHOsL6trz2Oe1ve17gCp/V3gf7vKyDA2ZfHkxkIxI5MgJNBMTSBQMMCApyGi6/rBHoCApwehrtrF4jjXgHO2mnzXGEcXLgCJ8/65NgqAU6OVdGmvoAx2tdwnwCBqQTiGKvlg+qp7G2XQE4CApycqlFfWwQ4XecKnPrGtR6tUcDJ8RoxrWoQAWN0EFYrJUBgSQEBzpJgFidQqYAAp9LCZtItAY4AJ5OhqBm5Cjg5zrUy2hUCxmhI+JcAgSkFBDhT6ts2gXwEBDj51KLGlghwBDg1jmt9WqOAk+M1YlrVIALG6CCsVkqAwJICApwlwSxOoFIBAU6lhc2kWwIcAU4mQ1EzchVwcpxrZbQrBIzRkPAvAQJTCjionlLftgnkIyDAyacWNbYk9jVnzpzpNjc3a+zigX3yHTgHElmgZQEnxy1Xv4y+G6Nl1EkrCdQuEAfVvsS49krrH4H9BQQ4+/t49nACsa8R4BzOsZhXx+W9/gpVMSWbvKFOjicvgQYcIGCMHgDkaQIERhGIg2oBzijcNkIgWwEBTralqaJhsa8R4FRRzoM7IcA52MgS2wWcHG/38FN+AsZofjXRIgItCsRBtQCnxerrM4G5gABnbuHe+gViXyPAWb9tlmsU4GRZlqwb5eQ46/Jo3BcEjFHDgACBHATioFqAk0M1tIHAdAICnOnsW9hy7GsEOC1U+wt9PHr0aHf69OnOR6gaKfgauhknxy1PEmtgtIoBBWKMnjp1qjt37tyAW7JqAgQI7C0QB9UCnL2NPEOgBQEBTgtVnq6Pcdzb8rlZU19iLMCZ7s1W6pZNEqVWrp12xxgV4LRTcz0lkKOAACfHqmgTgfEFBDjjm7e0xTjuFeA0UnUBTiOFXmM3TRJrxLSqQQRijApwBuG1UgIEFhQQ4CwIZTEClQsIcCov8MTdi+NeAc7EhRhr8wKcsaTr2Y5Jop5a1tqTGKMCnForrF8EyhCIuchHqMqol1YSGEogzQUtn1wP5Wq9WwKxr2l5jDX5ESonOqaARQXiN4otTxKLWlluGoHYkZnXpvG3VQIEtgRiLhLgGBEE2hYQ4LRd/6F7H/uals/NBDhDjzLrL1pAgFN0+ZpofOzIBDhNlFsnCWQrEHNRywfV2RZHwwiMKJCOnc+fP99tbm6OuFWbakXAvqbrBDitjHb9XElAgLMSmxeNKBA7MgHOiOg2RYDARQIxFwlwLqLxAIGmBNJcYB5oquSjdta+RoAz6oCzsfIEBDjl1ay1FseOTIDTWuX1l0BeAjEXOXHLqy5aQ2BsAQHO2OJtbc++ptEAx8FFW2/0w/RWgHMYPa8dQyB2ZAKcMbRtgwCBvQRiLnKMtZeQxwm0ISDAaaPOU/XSvqbRAMcX7E31litvuwKc8mrWWotjRybAaa3y+ksgL4GYiwQ4edVFawiMLSDAGVu8re3Z1zQW4KThnYouwGnrjX6Y3gpwDqPntWMIxI5MgDOGtm0QILCXQMxFApy9hDxOoH6Bo0ePdqdPn+7MA/XXeqoe2tcIcKYae7ZbiIAAp5BCNdzM2JEJcBoeBLpOIAOBmIucuGVQDE0gMJGAAGci+IY2a1/TaICTxriTnYbe6YfoqgDnEHheOrhAHCilDZnTBue2AQIE9hFwUL0PjqcINCJw8uTJ7sSJE67AaaTeU3TTvqbBACdOyJ3sTPGWK2+bMV78RrG82rXQYgFOC1XWRwL5C/TnIvvL/OulhQSGEogAx3nWUMLWK8BpMMCJgwzfg2MCWERAgLOIkmWmEoj5LG3fwdJUVbBdAgT6c5EAx3gg0K5AnFwfP368XQQ9H1QgxljL+5pLjhw5cs2gypmtvH+QYXLJrDgZNkeAk2FRNOmCQH8+E+BcYHGHAIGRBfpzUcsH1SOz2xyBrARiHjAHZFWW6hojwGnwCpw0iuOk3AlPde/ptXcoxoqd0dpprXANAnGwlFZlPlsDqFUQILCSQH8usr9cidCLCBQvEB+fMgcUX8qsOyDAaTzA8TGqrN+fWTROgJNFGTRiD4H+SZMAZw8kDxMgMLhAfy5y8jY4tw0QyFIgjpl9wiHL8lTTqAhwWj7ube4jVGn09g80Wi5+Ne/kATsSOyMHpAMiW/XKAuaylem8kACBNQr05yL7yzXCWhWBQgRcfVNIoSpopgCn0Stw0tiNicZVOBW8kwfsggBnQFyrPrRA/6TJb7wOzWkFBAisKNCfiwQ4KyJ6GYGCBZxUF1y8wppurDUc4KSx6uS8sHfsBM01RiZAt8mFBfonTQKchdksSIDAmgX6c5EAZ824Vkcgc4H4pbj3fuaFqqB5/X1Ny5+iafIjVDF+DYKQ8O9eAgKcvWQ8noNAfw4T4ORQEW0g0KZAfy5yEtfmGNDrNgX6733HIW2OgTF73R9vApwx5TPbVqTGqVktD4TMypJNcwQ42ZRCQ3YR6O/IHDjtAuQhAgRGEejPRQKcUchthMDkAt73k5eguQb0x1zL5+1NX4ETo74f4jgJChX/JgEBjnGQs0B/R2buyrlS2kagfoF0LHX729++O3/+fLe5uVl/h/WQQMMC/eOPlk+kGx4Ck3TduNtiF+B8cfhFiJO+1Dj99ujcuXOTDEwbzUtAgJNXPbRmu0B/RybA2W7jJwIExhdI+0wBzvjutkhgTIE4Z0rbFN6MKW9b/ePelseeAKf3XuhPSC4B7sE0fFeA03DxC+h6f0cmwCmgYJpIoHKBNCf5BVjlRda9ZgXS+/vEiRPdsWPHOn/Ft9lhMGnH+8e9ApxJS5HXxuMS4DQ5pZsgJ6/6jN0aAc7Y4ra3jEB/RybAWUbOsgQIECBAgMAiAjuDG59UWETNMkMI9I97BThDCBe+zv7VOKkrabJKabPfLBVe2CWbL8BZEsziowr0d2QCnFHpbYwAAQIECFQpkI4t0i2utkn3fcVEUnCbWqB/3CvAmboaGW9/5xU5qakpzEm3NJnFTbATEnX9K8Cpq5419ibCZgFOjdXVJwIECBAgMIxABDVp7emTB+lLyON++jfOc9J5j/OcGY3/TSwgwNkqgO/AWWIgphOldEuJ9NS3mFSnbkft2//6r//6WRf/9V//9dBdTV/s6EZgCIGv/Mqv7D74wQ8OsWrrJECAAIGeQJzk9h5yl8DSAvFVDUu/cMAXxLmFwGZAZKs+lIAAZ4tPgHOIYbQzuV5lVVMfCOS4A1nF0WsIECBAgAABAgQIjCUQgcdY29tvO6v8kjDa7+qa/WQ9l5OAAGerGgKcnEaltnT9UCxnjlqCr6kDxBxqXEstc7DUBgIE6hSIE706e7d4r1Y5SV587eMuWVpNhQzjjg9bI5CjgABnqyoCnBxHpzYRIECAwEoCpYTAK3Vu4hc5gZq4ADZPgAABAgQaFhDgbBVfgNPwm0DXCRAgQIAAAQIECBAgQIBA7gICnK0KCXByH6naR4AAAQIECBAgQIAAAQIEGhYQ4GwVX4DT8JtA1wkQIECAAAECBAgQIECAQO4CApytCglwch+p2keAAAECBAgQIECAAAECBBoWEOBsFV+A0/CbQNcJECBAgAABAgQIECBAgEDuAgKcrQoJcHIfqdpHgAABAgR6AukAxl+E6oG4S4AAAQIECFQv0A9wjh8/Xn1/9+qgAGcvGY8TIECAAIHMBE6ePNmdOHGiO3XqlBAns9poDgECBAgQIDCcQBwDpS0IcIZztmYCBAgQIEBgDQL9AxcBzhpArYIAAQIECBAoRqB/HCTAKaZsGkqAAAECBNoU6B+4CHDaHAN6TYAAAQIEWhXoHwcJcFodBfpNgAABAgQKEbjiiisutPTMmTPd5ubmhZ/dIUCAAAECBAjULCDA2aqu78CpeZTrGwECBAhUIdA/aEkdOnv2bLexsVFF33SCAAECBAgQIHCQQP9YyBU4B2l5ngABAgQIEJhMoH/1TTTCx6hCwr8ECBAgQIBA7QICnK0KuwKn9pGufwQIECBQtEAcsKSPTaW/QBU3V+GEhH8JECBAgACB2gXieCj10xU4tVdb/wgQIECAQKGzgYiAAAApZUlEQVQCcfVNOliJ+9GVlg9gwsC/BAgQIECAQP0CApytGrsCp/6xrocECBAgUKjA0aNHu9OnT3fxpcU7Axwfoyq0sJpNgAABAgQILCUgwNniEuAsNWwsTIAAAQIExhOIg5W9AhwfoxqvFrZEgAABAgQITCcQx0SpBS1fgSzAmW4M2jIBAgQIENhXIK64iQOV+Ln/fTjx3L4r8iQBAgQIECBAoGABAc5W8QQ4BQ9iTSdAgACBegV2fnwq9TQCnPTRqfTRqnTzMaoZg/8RIECAAAECFQsIcLaKK8CpeJDrGgECBAiUKxAHKvHxqdSTfoBz7Nix2V+l8jGqcmus5QQIECBAgMBiAnFclJZu+epjAc5i48VSBAgQIEBgVIEIa+IgJa7ISY1IV92kW1yFE8vMHvQ/AgQIECBAgEBlAgKcrYIKcCob2LpDgAABAuULRFjTv/omHku9i8Dm8ssv79KVOD5GVX7N9YAAAQIECBDYW0CAs2UjwNl7jHiGAAECBAhMIhAHKRHUpEbsFuDEYz5GNUmZbJQAAQIECBAYSSCOjdLm+sdHI20+m80IcLIphYYQIECAAIEtgfTxqf7VN+nRCGvS/f6BS1yF038sLeNGgAABAgQIEKhFQICzVUkBTi0jWj8IECBAoAqBCGoWDXBi+fQxqg984APdhz70oSocdIIAAQIECBAgEAICnC0JAU6MCP8SIECAAIEMBFIgc+LEiW5jY2NbayKoSQ/uvNomrth55zvf2V155ZXbXucHAgQIECBAgEDpAgKcrQoKcEofydpPgAABAk0I7BfgNAGgkwQIECBAgECzAgKcrdILcJp9C+g4AQIECJQkIMApqVraSoAAAQIECKxTQICzpSnAWeeosi4CBAgQIDCQgABnIFirJUCAAAECBLIXiD/a0Ppf3hTgZD9UNZAAAQIECOz9V6jYECBAgAABAgRqFxDgbFVYgFP7SNc/AgQIEKhCwBU4VZRRJwgQIECAAIEVBAQ4W2gCnBUGj5cQIECAAIGxBQQ4Y4vbHgECBAgQIJCLgABnqxICnFxGpHYQIECAAIF9BAQ4++B4igABAgQIEKhaQICzVV4BTtXDXOcIECBAoBYBAU4tldQPAgQIECBAYFkBAc6WmABn2ZFjeQIECBAgMIGAAGcCdJskQIAAAQIEshAQ4GyVQYCTxXDUCAIECBAgsL+AAGd/H88SIECAAAEC9QoIcLZqK8Cpd4zrGQECBAhUJCDAqaiYukKAAAECBAgsJSDA2eIS4Cw1bCxMgAABAgSmETh58mR34sSJ2caPHz8+TSNslQABAgQIECAwgYAAZwtdgDPB4LNJAgQIECCwrIAAZ1kxyxMgQIAAAQK1CAhwtiopwKllROsHAQIECFQtIMCpurw6R4AAAQIECOwjIMDZwhHg7DNIPEWAAAECBHIREODkUgntIECAAAECBMYWEOBsiQtwxh55tkeAAAECBFYQEOCsgOYlBAgQIECAQBUCApytMgpwqhjOOkGAAAECtQsIcGqvsP4RIECAAAECewkIcLZkBDh7jRCPEyBAgACBjAQEOBkVQ1MIECBAgACBUQUEOFvcApxRh52NESBAgACB1QQiwDl79my3sbGx2kq8igABAgQIECBQoIAAZ6toApwCB68mEyBAgEB7AgKc9mquxwQIECBAgMCWgABny0GA4x1BgAABAgQKEBDgFFAkTSRAgAABAgQGERDgbLEKcAYZXlZKgAABAgTWKyDAWa+ntREgQIAAAQLlCAhwtmolwClnzGopAQIECDQsIMBpuPi6ToAAAQIEGhe44oorZgKtfxegAKfxN4LuEyBAgEAZAgKcMuqklQQIECBAgMD6BSLAOXPmTLe5ubn+DRSyRgFOIYXSTAIECBBoW0CA03b99Z4AAQIECLQsIMDZqr4Ap+V3gb4TIECAQDECApxiSqWhBAgQIECAwJoFBDhboAKcNQ8sqyNAgAABAkMICHCGULVOAgQIECBAoAQBAc5WlQQ4JYxWbSRAgACB5gUEOM0PAQAECBAgQKBZAQHOVukFOM2+BXScAAECBEoSEOCUVC1tJUCAAAECBNYpIMDZ0hTgrHNUWRcBAgQIEBhIQIAzEKzVEiBAgAABAtkLCHC2SiTAyX6oaiABAgQIEOg6AY5RQIAAAQIECLQqIMDZqrwAp9V3gH4TIECAQFECl19+eXfs2LHu7Nmz3cbGRlFt11gCBAgQIECAwGEEBDhbegKcw4wiryVAgAABAiMJCHBGgrYZAgQIECBAIDsBAc5WSQQ42Q1NDSJAgAABAhcLCHAuNvEIAQIECBAg0IaAAGerzgKcNsa7XhIgQIBA4QICnMILqPkECBAgQIDAygICnC06Ac7KQ8gLCRAgQIDAeAICnPGsbYkAAQIECBDIS0CAs1UPAU5e41JrCBAgQIDArgICnF1ZPEiAAAECBAg0ICDA2SqyAKeBwa6LBAgQIFC+gACn/BrqAQECBAgQILCagABny02As9r48SoCBAgQIDCqgABnVG4bI0CAAAECBDISEOBsFUOAk9Gg1BQCBAgQILCXgABnLxmPEyBAgAABArULCHC2KizAqX2k6x8BAgQIVCEgwKmijDpBgAABAgQIrCAgwNlCE+CsMHi8hAABAgQIjC0gwBlb3PYIECBAgACBXAQEOFuVEODkMiK1gwABAgQI7CMgwNkHx1MECBAgQIBAtQJHjx7tTp8+PevfmTNnus3NzWr7elDHBDgHCXmeAAECBAhkIBABTusHLhmUQhMIECBAgACBEQUEOHNsAc7cwj0CBAgQIJCtgAAn29JoGAECBAgQIDCggABnjivAmVu4R4AAAQIEshUQ4GRbGg0jQIAAAQIEBhToBzinTp3qzp07N+DW8l61ACfv+mgdAQIECBCYCQhwDAQCBAgQIECgRQEBzrzqApy5hXsECBAgQCBbAQFOtqXRMAIECBAgQGBAAQHOHFeAM7dwjwABAgQIZCsgwMm2NBpGgAABAgQIDCggwJnjCnDmFu4RIECAAIFsBQQ42ZZGwwgQIECAAIEBBQQ4c1wBztzCPQIECBAgkK2AACfb0mgYAQIECBAgMKCAAGeOK8CZW7hHgAABAgSyFRDgZFsaDSNAgAABAgQGFBDgzHEFOHML9wgQIECAQLYCV1xxxaxtZ86c6TY3N7Ntp4YRIECAAAECBNYpIMCZawpw5hbuESBAgACBbAUEONmWRsMIECBAgACBAQUEOHNcAc7cwj0CBAgQIJCtgAAn29JoGAECBAgQIDCggABnjivAmVu4R4AAAQIEshUQ4GRbGg0jQIAAAQIEBhQQ4MxxBThzC/cIECBAgEC2AgKcbEujYQQIECBAgMCAAgKcOa4AZ27hHgECBAgQyFZAgJNtaTSMAAECBAgQGFBAgDPHFeDMLdwjQIAAAQLZCghwsi2NhhEgQIAAAQIDCghw5rgCnLmFewQIECBAIFsBAU62pdEwAgQIECBAYEABAc4cV4Azt3CPAAECBAhkKyDAybY0GkaAAAECBAgMKCDAmeMKcOYW7hEgQIAAgWwFBDjZlkbDCBAgQIAAgQEFBDhzXAHO3MI9AgQIECCQrYAAJ9vSaBgBAgQIECAwoMDJkye7EydOzLZw6tSp7ty5cwNuLe9VC3Dyro/WESBAgACBmYAAx0AgQIAAAQIEWhQQ4MyrLsCZW7hHgAABAgSyFRDgZFsaDSNAgAABAgQGFBDgzHEFOHML9wgQIECAQLYCApxsS6NhBAgQIECAwIACApw5rgBnbuEeAQIECBDIVkCAk21pNIwAAQIECBAYUKAf4Bw/fnzALeW/agFO/jXSQgIECBAg0AlwDAICBAgQIECgRQEBzrzqApy5hXsECBAgQCBbAQFOtqXRMAIECBAgQGBAAQHOHFeAM7dwjwABAgQIZCsgwMm2NBpGgAABAgQIDCggwJnjCnDmFu4RIECAAIFsBQQ42ZZGwwgQIECAAIEBBQQ4c1wBztzCPQIECBAgkK1ABDinTp3qzp07l207NYwAAQIECBAgsE4BAc5cU4Azt3CPAAECBAhkKyDAybY0GkaAAAECBAgMKCDAmeMKcOYW7hEgQIAAgSwFjh492p0+fXrWNlfgZFkijSJAgAABAgQGEhDgzGEFOHML9wgQIECAQJYCApwsy6JRBAgQIECAwAgCApw5sgBnbuEeAQIECBDIUkCAk2VZNIoAAQIECBAYQUCAM0cW4Mwt3CNAgAABAlkKCHCyLItGESBAgAABAiMICHDmyAKcuYV7BAgQIEAgSwEBTpZl0SgCBAgQIEBgBAEBzhxZgDO3cI8AAQIECGQpIMDJsiwaRYAAAQIECIwgIMCZIwtw5hbuESBAgACBLAUEOFmWRaMIECBAgACBEQQEOHNkAc7cwj0CBAgQIJClgAAny7JoFAECBAgQIDCCgABnjizAmVu4R4AAAQIEshQQ4GRZFo0iQIAAAQIERhAQ4MyRBThzC/cIECBAgECWAgKcLMuiUQQIECBAgMAIAgKcObIAZ27hHgECBAgQyFJAgJNlWTSKAAECBAgQGEHg8ssv744dOzbb0vHjx0fYYr6bEODkWxstI0CAAAECMwEBjoFAgAABAgQItCogwJlXXoAzt3CPAAECBAhkKSDAybIsGkWAAAECBAiMICDAmSMLcOYW7hEgQIAAgSwFBDhZlkWjCBAgQIAAgREEBDhzZAHO3MI9AgQIECCQpYAAJ8uyaBQBAgQIECAwgoAAZ44swJlbuEeAAAECBLIUEOBkWRaNIkCAAAECBEYQiADn7Nmz3cbGxghbzHcTApx8a6NlBAgQIEBgJiDAMRAIECBAgACBVgUEOPPKC3DmFu4RIECAAIEsBQQ4WZZFowgQIECAAIERBAQ4c2QBztzCPQIECBAgkKWAACfLsmgUAQIECBAgMIKAAGeOLMCZW7hHgAABAgSyFBDgZFkWjSJAgAABAgRGEBDgzJEFOHML9wgQIECAQJYCApwsy6JRBAgQIECAwAgCApw5sgBnbuEeAQIECBDIUkCAk2VZNIoAAQIECBAYQUCAM0cW4Mwt3CNAgAABAlkKnDx5sjtx4sSsbadOnerOnTuXZTs1igABAgQIECCwbgEBzlxUgDO3cI8AAQIECGQpIMDJsiwaRYAAAQIECIwgIMCZIwtw5hbuESBAgACBLAUEOFmWRaMIECBAgACBEQQEOHNkAc7cwj0CBAgQIJClQD/AOX78eJZt1CgCBAgQIECAwBACApy5qgBnbuEeAQIECBDIUkCAk2VZNIoAAQIECBAYQUCAM0cW4Mwt3CNAgAABAlkKCHCyLItGESBAgAABAiMICHDmyAKcuYV7BAgQIEAgSwEBTpZl0SgCBAgQIEBgBAEBzhxZgDO3cI8AAQIECGQpIMDJsiwaRYAAAQIECIwgIMCZIwtw5hbuESBAgACBLAUEOFmWRaMIECBAgACBEQSuuOKK2VbOnj3bbWxsjLDFfDchwMm3NlpGgAABAgRmAgIcA4EAAQIECBBoVUCAM6+8AGdu4R4BAgQIEMhSoKYA54Y3vGF36aWXdv/3f//Xffazn83Se5FGpT6kvqTbZz7zme6qq67a9WXXvva1uxvc4Aaz5/73f/+3+9znPrfrch4kQIAAAQIEdhcQ4MxdBDhzC/cIECBAgECWAjUFOC960Yu6W9/61t2znvWs7vWvf3123je60Y26a13rWt0nP/nJ7pprrtmzfV/1VV/VveIVr5g9f+7cue4xj3lM9/nPf/6i5Z/ylKd0d73rXWeP//AP/3D34Q9/+KJlPECAAAECBAjsLSDAmdsIcOYW7hEgQIAAgSwFBDjjleWNb3xjd/3rX7970IMe1P33f//3vhv+3u/93u7xj3/8bJn0BYt/9Ed/tG35u9zlLt3Tn/702WPPeMYzuje84Q3bnvcDAQIECBAgcLCAAGduJMCZW7hHgAABAgSyFBDgjFeWZQKcSy65pHvmM5/Zfeu3fuusgf3Q50u/9Eu7F7/4xd2Nb3zj7q1vfWv3pCc9abxO2BIBAgQIEKhIQIAzL6YAZ27hHgECBAgQyFKg9gDnete73uxjS+l7cdLHllLo8f/+3//rPvShD3Uf/OAHt32UKYUm6b+0XPrvOte5Tneb29xm9j00733ve7urr756Ww1j3el7anZ+xCldaZPW9elPf3r2vTzXve51u1e/+tWzK3B+7Md+rHvf+943W++2Fe744aY3vWn3kpe8ZPaaK6+8sjt16tRsOymwudvd7jb7rp8HPvCB3Uc/+tEdr/QjAQIECBAgsIhABDhnzpzpNjc3F3lJtcsIcKotrY4RIECAQC0CtQc4z3ve87rb3e52sz8NeuLEie7o0aMXSvc///M/3aMe9ajuAx/4wOyxe93rXt0TnvCE7pWvfGWXviD4vve974VlUwD0tKc9rXvb29524bEXvvCF3WWXXdY9+tGP7s6fP3/h8XQnrrb5wR/8wdk2n/zkJ297Pm37h37oh7Y9ttsP3/Ed39E99alPnT2VPkqVQqf0kal0+7mf+7nuLW95y+y+/xEgQIAAAQLLCwhw5mYCnLmFewQIECBAIEuB2gOc3/iN3+i+8Ru/8YL9m9/85tmVL+k7ZNJVMv/2b//WPexhD5s9f+9737v7mZ/5mQvL/uM//mOX/vvmb/7m7ha3uMXs8cc+9rHdO9/5ztn9CHDSlTHpy4b7twhwUkhzs5vdrPv+7//+7h73uMdskfSxp//6r//qfuu3fqv/kj3vp/Dnu77ru2bPpyAptTt9500EOXu+0BMECBAgQIDAvgICnDmPAGdu4R4BAgQIEMhSoKUA56d/+qe7d73rXbM63Pa2t70QoNz97nefhTr9AOdlL3tZ9/znP3+2bPooVPrC4G//9m/v/uM//qNLV/Kkj0wtGuCkq23SLUKd/vfZzJ444H/977xJi6b1pTZ86lOfOuCVniZAgAABAgT2ExDgzHUEOHML9wgQIECAQJYCrQQ46XPt6fPt/VsEKj/+4z/e/fM//3MXAU66yiX9FajPfvazFxZP30fzh3/4h7Of08eiPvKRj4wW4KSN9v9kuKtvLpTFHQIECBAgcCgBAc6cT4Azt3CPAAECBAhkKdBKgJO++Dd9dKl/S1fYpC8pjo9ARYCTPg6VHtt5i8AnruQZ6wqcb/u2b7vo41KPecxjur/7u7/b2UQ/EyBAgAABAksICHDmWAKcuYV7BAgQIEAgS4FWApwIafpF2CvAed3rXtc9+9nP7i86ux/Lpy86fsc73rHnFTjpI1d/+Zd/OXtN+g6cw3yEKv3VrFe84hWz771505ve1KWPU93pTnfqPvaxj3U/8iM/4mNUF1XJAwQIECBAYHEBAc7cSoAzt3CPAAECBAhkKSDAufgKnBS+/PzP//xF9XrVq141+0LiBz/4wbM/A77XFTj9j1sdNsD5xV/8xdl376TA5iEPeUh3gxvcoPv93//9Wdt8lOqiEnmAAAECBAgsJSDAmXMJcOYW7hEgQIAAgSwFBDgXBzjpz4o/4AEP2Favr/7qr+5e/vKXzx67613v2l199dWzL0FOX4a88895p79a9ZznPGe27GECnO/5nu/pfvZnf3a2nic+8Ynd29/+9tn9+9znPl36CFW67dz27EH/I0CAAAECBBYSEODMmQQ4cwv3CBAgQIBAlgICnIsDnFSoFMC89rWvndXs0ksv7dKf8v7O7/zO7m//9m+7xz3ucbPH058UT38e/E/+5E+6Zz7zmbPHrne963W/8zu/093ylrec/dwPcNL60keiHv7wh3f/9E//NHt+r//d/OY379Jfwkq3nVfaXOta1+pOnz7d3e52t+vSFy4/8IEP7D760Y/utSqPEyBAgAABAnsICHDmMAKcuYV7BAgQIEAgSwEBzu4BTirWX/3VX3Xvec97ujvc4Q6zLztOj6Ww5P3vf3+6293tbnfr0pcjp1sKdj75yU92x44dm4U0swe/8L9+gPMrv/Ir3bd+67fOPn6VvlD5t3/7t2Oxbf+mwOjXfu3Xum/8xm+cfddN+shWWnf/9jVf8zXdS1/60tlDb3nLW2ZX4vSfd58AAQIECBA4WECAMzcS4Mwt3CNAgAABAlkKXH755bPQITXu+PHjWbZx0Ua96EUv6m5961t3z3rWs7rXv/71s5c973nPm12p8qhHPaq78sort60qvpT40Y9+dHf+/PkLf0b8zW9+8+y7Zu54xzteWD59B80znvGMCx9jSk+kLytOV9M86EEPurBcuiImXR2TPuaU/sJV/MnxtMCd73zn2Z8Dv/71rz/7YuMU7ux2u9/97tf91E/91Oypxz/+8d3f/M3f7LZYd//737975CMfOXsufWdPfHHyrgt7kAABAgQIELhIQIAzJxHgzC3cI0CAAAECWQrUFOAcFjj+jHj6qFP6CFX6uNM3fMM3dB//+MdnV+J85jOf2XUT6WNTt7jFLWaBzn/+5392ey2XXpzCmyNHjnSf+MQnLrqqZteVe5AAAQIECBAYTECAM6cV4Mwt3CNAgAABAlkKCHDmZdkZ4MyfcY8AAQIECBCoUUCAM6+qAGdu4R4BAgQIEMhSQIAzL4sAZ27hHgECBAgQaEFAgDOvsgBnbuEeAQIECBDIUkCAMy+LAGdu4R4BAgQIEKhd4OjRo7PvrUv9PHPmTLe5uVl7l/ftnwBnXx5PEiBAgACB6QUEOPMa3OxmN+u+7uu+rvvwhz/cvfe9750/4R4BAgQIECBQnYAAZ3tJBTjbPfxEgAABAgSyE4gA5+zZs93GxkZ27dMgAgQIECBAgMAQAgKc7aoCnO0efiJAgAABAtkJCHCyK4kGESBAgAABAiMICHC2Iwtwtnv4iQABAgQIZCcgwMmuJBpEgAABAgQIjCAgwNmOLMDZ7uEnAgQIECCQnYAAJ7uSaBABAgQIECAwgoAAZzuyAGe7h58IECBAgEB2AgKc7EqiQQQIECBAgMAIAgKc7cgCnO0efiJAgAABAtkJCHCyK4kGESBAgAABAiMI9AOcU6dOdefOnRthq/luQoCTb220jAABAgQIzAQEOAYCAQIECBAg0KKAAGd71QU42z38RIAAAQIEshMQ4GRXEg0iQIAAAQIERhAQ4GxHFuBs9/ATAQIECBDITkCAk11JNIgAAQIECBAYQUCAsx1ZgLPdw08ECBAgQCA7AQFOdiXRIAIECBAgQGCHQApbjh071p09e3Zt31UjwNmOLMDZ7uEnAgQIECCQnYAAJ7uSaBABAgQIECCwQ+DkyZPdiRMnLjx65syZbnNz88LPq9wR4GxXE+Bs9/ATAQIECBDITkCAk11JNIgAAQIECBDYQ2C3IGfVq3IEONuRBTjbPfxEgAABAgSyExDgZFcSDSJAgAABAgQOEEhBTrrFVTnpipx0W+aqHAHOjOzC/wQ4FyjcIUCAAAECeQoIcPKsi1YRIECAAAECiwnsdlVOeuVBYY4AZ7uvAGe7h58IECBAgEB2AgKc7EqiQQQIECBAgMAKAjuvykmr2O/KHAHOdmQBznYPPxEgQIAAgewEDhPgXHHFFdn1JxqUPg/vRoAAAQIE1iWQ/gKSWx0Cp06dmv0lKwHO9noKcLZ7+IkAAQIECGQncJgAJ/2m6/a3v/3sz3pm1zENakZAWLd6qZ2Qrm7nlQQIlCmQ9hkbGxuzxkeAs46/aFWmxvZWC3C2e/iJAAECBAhkJ3CYACe7zmgQAQIECBAgsLJACjRquaWAOr7gOPUpwv4U1pw7d27WzQhwjh8/Xku3D9UPAc6h+LyYAAECBAgMLxAfg+r/Rmr4rdoCAQIECBAgQGC9AimQSaFN/+rCdHzTD212bjG9JgKdnc+19rMAp7WK6y8BAgQIFCcgwCmuZBpMgAABAgQIfFEgQpv0YwQ3B4U28HYXEODs7uJRAgQIECCQjYAAJ5tSaAgBAgQIECCwgMBuoU16WbrSJoU3rqhZAHGXRQQ4u6B4iAABAgQI5CQgwMmpGtpCgAABAgQI7CUQwU1caZOWc7XNXlrLPy7AWd7MKwgQIECAwKgCApxRuW2MAAECBAgQWEEg/eXL+FLiFNqk237fbbPCJpp/iQCn+SEAgAABAgRyFxDg5F4h7SNAgAABAgSuc53rdNe+9rVnENdcc83s36uuuqr7/Oc/D2dNAgKcNUFaDQECBAgQGEpAgDOUrPUSIECAAAECBMoREOCUUystJUCAAIFGBQQ4jRZetwkQIECAAAECPQEBTg/DXQIECBAgkKOAACfHqmgTAQIECBAgQGBcAQHOuN62RoAAAQIElhYQ4CxN5gUECBAgQIAAgeoEBDjVlVSHCBAgQKA2gQhw0l9y2NzcrK17+kOAAAECBAgQILCAgABnASSLECBAgACBKQUEOFPq2zYBAgQIECBAIA8BAU4eddAKAgQIECCwp4AAZ08aTxAgQIAAAQIEmhEQ4DRTah0lQIAAgVIFBDilVk67CRAgQIAAAQLrExDgrM/SmggQIECAwCACApxBWK2UAAECBAgQIFCUgACnqHJpLAECBAi0KCDAabHq+kyAAAECBAgQ2C4gwNnu4ScCBAgQIJCdgAAnu5JoEAECBAgQIEBgdAEBzujkNkiAAAECBJYTEOAs52VpAgQIECBAgECNAgKcGquqTwQIECBQlYAAp6py6gwBAgQIECBAYCUBAc5KbF5EgAABAgTGExDgjGdtSwQIECBAgACBXAUEOLlWRrsIECBAgMAXBQQ4hgIBAgQIECBAgIAAxxggQIAAAQKZCwhwMi+Q5hEgQIAAAQIERhAQ4IyAbBMECBAgQOAwAgKcw+h5LQECBAgQIECgDgEBTh111AsCBAgQqFhAgFNxcXWNAAECBAgQILCggABnQSiLESBAgACBqQQEOFPJ2y4BAgQIECBAIB8BAU4+tdASAgQIECCwq4AAZ1cWDxIgQIAAAQIEmhIQ4DRVbp0lQIAAgRIFBDglVk2bCRAgQIAAAQLrFRDgrNfT2ggQIECAwFoFjh492p0+fXq2zjNnznSbm5trXb+VESBAgAABAgQIlCEgwCmjTlpJgAABAo0KCHAaLbxuEyBAgAABAgR2CAhwdoD4kQABAgQI5CQgwMmpGtpCgAABAgQIEJhOQIAznb0tEyBAgACBAwUEOAcSWYAAAQIECBAg0ISAAKeJMuskAQIECJQqIMAptXLaTYAAAQIECBBYr4AAZ72e1kaAAAECBNYqIMBZK6eVESBAgAABAgSKFRDgFFs6DSdAgACBFgQEOC1UWR8JECBAgAABAgcLCHAONrIEAQIECBCYTECAMxm9DRMgQIAAAQIEshIQ4GRVDo0hQIAAAQLbBQQ42z38RIAAAQIECBBoVUCA02rl9ZsAAQIEihAQ4BRRJo0kQIAAAQIECAwuIMAZnNgGCBAgQIDA6gICnNXtvJIAAQIECBAgUJOAAKemauoLAQIECFQnIMCprqQ6RIAAAQIECBBYSUCAsxKbFxEgQIAAgXEEBDjjONsKAQIECBAgQCB3AQFO7hXSPgIECBBoWqAf4Jw6dao7d+5c0x46T4AAAQIECBBoVUCA02rl9ZsAAQIEihAQ4BRRJo0kQIAAAQIECAwuIMAZnNgGCBAgQIDA6gICnNXtvJIAAQIECBAgUJOAAKemauoLAQIECFQnIMCprqQ6RIAAAQIECBBYSUCAsxKbFxEgQIAAgXEEBDjjONsKAQIECBAgQCB3AQFO7hXSPgIECBBoWkCA03T5dZ4AAQIECBAgcEFAgHOBwh0CBAgQIJCfgAAnv5poEQECBAgQIEBgCgEBzhTqtkmAAAECBBYUEOAsCGUxAgQIECBAgEDlAgKcygusewQIECBQtoAAp+z6aT0BAgQIECBAYF0CApx1SVoPAQIECBAYQECAMwCqVRIgQIAAAQIEChQQ4BRYNE0mQIAAgXYEBDjt1FpPCRAgQIAAAQL7CQhw9tPxHAECBAgQmFhAgDNxAWyeAAECBAgQIJCJgAAnk0JoBgECBAgQ2E1AgLObiscIECBAgAABAu0JCHDaq7keEyBAgEBBAgKcgoqlqQQIECBAgACBAQUEOAPiWjUBAgQIEDisgADnsIJeT4AAAQIECBCoQ0CAU0cd9YIAAQIEKhUQ4FRaWN0iQIAAAQIECCwpIMBZEsziBAgQIEBgTAEBzpjatkWAAAECBAgQyFdAgJNvbbSMAAECBAh0AhyDgAABAgQIECBAIAkIcIwDAgQIECCQsUAKcE6cONEdO3asO3XqVHfu3LmMW6tpBAgQIECAAAECQwkIcIaStV4CBAgQILBGgZMnT3abm5trXKNVESBAgAABAgQIlCQgwCmpWtpKgAABAgQIECBAgAABAgQINCkgwGmy7DpNgAABAgQIECBAgAABAgQIlCQgwCmpWtpKgAABAgQIECBAgAABAgQINCkgwGmy7DpNgAABAgQIECBAgAABAgQIlCQgwCmpWtpKgAABAgQIECBAgAABAgQINCkgwGmy7DpNgAABAgQIECBAgAABAgQIlCQgwCmpWtpKgAABAgQIECBAgAABAgQINCkgwGmy7DpNgAABAgQIECBAgAABAgQIlCQgwCmpWtpKgAABAgQIECBAgAABAgQINCkgwGmy7DpNgAABAgQIECBAgAABAgQIlCQgwCmpWtpKgAABAgQIECBAgAABAgQINCkgwGmy7DpNgAABAgQIECBAgAABAgQIlCQgwCmpWtpKgAABAgQIECBAgAABAgQINCkgwGmy7DpNgAABAgQIECBAgAABAgQIlCQgwCmpWtpKgAABAgQIECBAgAABAgQINCkgwGmy7DpNgAABAgQIECBAgAABAgQIlCQgwCmpWtpKgAABAgQIECBAgAABAgQINCkgwGmy7DpNgAABAgQIECBAgAABAgQIlCQgwCmpWtpKgAABAgQIECBAgAABAgQINCkgwGmy7DpNgAABAgQIECBAgAABAgQIlCQgwCmpWtpKgAABAgQIECBAgAABAgQINCkgwGmy7DpNgAABAgQIECBAgAABAgQIlCQgwCmpWtpKgAABAgQIECBAgAABAgQINCkgwGmy7DpNgAABAgQIECBAgAABAgQIlCQgwCmpWtpKgAABAgQIECBAgAABAgQINCkgwGmy7DpNgAABAgQIECBAgAABAgQIlCQgwCmpWtpKgAABAgQIECBAgAABAgQINCkgwGmy7DpNgAABAgQIECBAgAABAgQIlCQgwCmpWtpKgAABAgQIECBAgAABAgQINCkgwGmy7DpNgAABAgQIECBAgAABAgQIlCQgwCmpWtpKgAABAgQIECBAgAABAgQINCkgwGmy7DpNgAABAgQIECBAgAABAgQIlCQgwCmpWtpKgAABAgQIECBAgAABAgQINCkgwGmy7DpNgAABAgQIECBAgAABAgQIlCQgwCmpWtpKgAABAgQIECBAgAABAgQINCkgwGmy7DpNgAABAgQIECBAgAABAgQIlCQgwCmpWtpKgAABAgQIECBAgAABAgQINCkgwGmy7DpNgAABAgQIECBAgAABAgQIlCQgwCmpWtpKgAABAgQIECBAgAABAgQINCkgwGmy7DpNgAABAgQIECBAgAABAgQIlCQgwCmpWtpKgAABAgQIECBAgAABAgQINCkgwGmy7DpNgAABAgQIECBAgAABAgQIlCQgwCmpWtpKgAABAgQIECBAgAABAgQINCkgwGmy7DpNgAABAgQIECBAgAABAgQIlCQgwCmpWtpKgAABAgQIECBAgAABAgQINCkgwGmy7DpNgAABAgQIECBAgAABAgQIlCQgwCmpWtpKgAABAgQIECBAgAABAgQINCkgwGmy7DpNgAABAgQIECBAgAABAgQIlCQgwCmpWtpKgAABAgQIECBAgAABAgQINCkgwGmy7DpNgAABAgQIECBAgAABAgQIlCQgwCmpWtpKgAABAgQIECBAgAABAgQINCkgwGmy7DpNgAABAgQIECBAgAABAgQIlCQgwCmpWtpKgAABAgQIECBAgAABAgQINCkgwGmy7DpNgAABAgQIECBAgAABAgQIlCQgwCmpWtpKgAABAgQIECBAgAABAgQINCkgwGmy7DpNgAABAgQIECBAgAABAgQIlCQgwCmpWtpKgAABAgQIECBAgAABAgQINCnw/wGiAPL0IhoE+gAAAABJRU5ErkJggg==" } }, "cell_type": "markdown", "metadata": {}, "source": [ "![image.png](attachment:image.png)" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "id": "0BTGrXZWQIkt" }, "outputs": [], "source": [ "class Attention(nn.Module):\n", " def __init__(self,n_attn_heads,n_kv_heads,hidden_size,max_len=256):\n", " super().__init__()\n", "\n", " assert hidden_size%n_attn_heads==0\n", " assert n_attn_heads%n_kv_heads==0\n", "\n", " self.head_dim = hidden_size // n_attn_heads\n", " kv_size = n_kv_heads * self.head_dim\n", " self.hidden_size = hidden_size\n", " self.n_attn_heads = n_attn_heads\n", " self.n_kv_heads = n_kv_heads\n", "\n", " self.q = nn.Linear(hidden_size, hidden_size, bias=False) #WQ\n", " self.k = nn.Linear(hidden_size, kv_size, bias=False) #WK\n", " self.v = nn.Linear(hidden_size, kv_size, bias=False) #WV\n", "\n", " self.register_buffer('tril',torch.tril(torch.ones(max_len,max_len)).view(1,1,max_len,max_len))\n", "\n", " def forward(self, x, echo = False):\n", "\n", " batch_size, seq_len, hidden_dim = x.shape\n", "\n", " #Pass the inputs through QKV matrices\n", " q = self.q(x) #Q\n", " k = self.k(x) #K\n", " v = self.v(x) #V\n", "\n", " q = q.view(batch_size, seq_len, self.n_attn_heads, self.head_dim).transpose(1, 2)\n", " k = k.view(batch_size, seq_len, self.n_kv_heads, self.head_dim).transpose(1, 2)\n", " v = v.view(batch_size, seq_len, self.n_kv_heads, self.head_dim).transpose(1, 2)\n", "\n", " # If n_attn_heads!=n_kv_heads, we need to repeat the same computation on same n_kv_heads for n_attn_heads/n_kv_heads times\n", " # So we just repeat n_kv_heads to match n_attn_heads size\n", " k = repeat_kv(k, self.n_attn_heads//self.n_kv_heads)\n", " v = repeat_kv(v, self.n_attn_heads//self.n_kv_heads)\n", "\n", " attention = (q @ k.transpose(-2,-1)) * (1.0/math.sqrt(self.hidden_size))\n", " attention = attention.masked_fill(self.tril[:,:,:seq_len,:seq_len]==0, float('-inf'))\n", " probs = nn.functional.softmax(attention,dim=-1)\n", " y = probs@v\n", " y = y.transpose(1,2).contiguous().reshape(batch_size, seq_len, -1)\n", "\n", "\n", " return y\n" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "id": "tqlQ_dDoIbwQ" }, "outputs": [], "source": [ "class MLP(nn.Module):\n", " def __init__(self, hidden_size, intermediate_size,):\n", " super().__init__()\n", "\n", " self.hidden_size = hidden_size\n", " self.intermediate_size = intermediate_size\n", "\n", " self.up = nn.Linear(hidden_size, intermediate_size, bias=False)\n", " self.gate = nn.Linear(hidden_size, intermediate_size, bias=False)\n", " self.down = nn.Linear(intermediate_size, hidden_size, bias=False)\n", " self.act_fn = nn.GELU()\n", "\n", " def forward(self,x):\n", "\n", " up = self.up(x)\n", " gate = self.gate(x)\n", "\n", " # note that * in torch is element wise multiplication. The two operands need to be of same size.\n", " return self.down(self.act_fn(up * gate))\n" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "id": "jHuI7TvQIjsQ" }, "outputs": [], "source": [ "class TransformerBlock(nn.Module):\n", " def __init__(self, hidden_size, n_attn_heads, n_kv_heads, intermediate_size,max_len, residual=True):\n", " super().__init__()\n", "\n", " self.attn = Attention(n_attn_heads,n_kv_heads,hidden_size,max_len)\n", " self.mlp = MLP(hidden_size, intermediate_size)\n", " self.residual = residual\n", " self.norm = nn.LayerNorm(hidden_size)\n", "\n", " def forward(self, x, normalise):\n", "\n", " if normalise:\n", " normalised_x = self.norm(x)\n", " attn_out = self.attn(normalised_x)\n", " else:\n", " attn_out = self.attn(x)\n", "\n", " if self.residual:\n", " attn_out = x + attn_out\n", "\n", " if normalise:\n", " normalised_x = self.norm(attn_out)\n", " mlp_out = self.mlp(normalised_x)\n", " else:\n", " mlp_out = self.mlp(attn_out)\n", "\n", " if self.residual:\n", " mlp_out = attn_out + mlp_out\n", "\n", " return mlp_out" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "id": "vachyBjHIrb2" }, "outputs": [], "source": [ "class NanoLlama(nn.Module):\n", "\n", " def __init__(self,n_layers, vocab_size, hidden_size, n_attn_heads, n_kv_heads, intermediate_size,max_len, residual, normalise=True):\n", " super().__init__()\n", " self.embedding = nn.Embedding(vocab_size, hidden_size)\n", " self.n_layers = n_layers\n", " self.layers = nn.ModuleList(\n", " [TransformerBlock(hidden_size, n_attn_heads, n_kv_heads, intermediate_size, max_len, residual) for _ in range(n_layers)]\n", " )\n", " self.normalise = normalise\n", " self.norm = nn.LayerNorm(hidden_size)\n", "\n", " def forward(self,x):\n", "\n", " x = self.embedding(x)\n", " for layer in self.layers:\n", " x = layer(x, self.normalise)\n", "\n", " if self.normalise:\n", " x = self.norm(x)\n", "\n", " return x\n" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "id": "bBehoFFvIpJM" }, "outputs": [], "source": [ "class NanoLlamaForCausalLM(nn.Module):\n", "\n", " def __init__(self,n_layers, vocab_size, hidden_size, n_attn_heads, n_kv_heads, intermediate_size,max_len=256, residual=True, normalise=True):\n", " super().__init__()\n", "\n", " self.model = NanoLlama(n_layers, vocab_size, hidden_size, n_attn_heads, n_kv_heads, intermediate_size,max_len, residual,normalise)\n", " self.lm_head = nn.Linear(hidden_size,vocab_size, bias=False)\n", " self.max_len = max_len\n", " self.n_layers = n_layers\n", " self.n_attn_heads = n_attn_heads\n", " self.n_kv_heads = n_kv_heads\n", " self.hidden_dim = hidden_size\n", "\n", "\n", " # Apply Kaiming uniform initialization to the weights of the linear layers\n", " for m in self.modules():\n", " if isinstance(m, nn.Linear):\n", " nn.init.kaiming_uniform_(m.weight, mode='fan_in', nonlinearity='relu')\n", "\n", " def forward(self,input_ids,targets=None):\n", " x = self.model(input_ids)\n", "\n", " if targets is not None:\n", " logits = self.lm_head(x)\n", " loss = nn.functional.cross_entropy(logits.view(-1, logits.size(-1)), targets.view(-1), ignore_index=-1)\n", " else:\n", " # we only need to pass the last token's outputs through lm_head. Rest we ignore.\n", " logits = self.lm_head(x[:, [-1], :])\n", " loss = None\n", "\n", " return logits,loss\n", "\n", " @torch.no_grad()\n", " def generate(self, input_ids, max_new_tokens=20, temperature=1.0, sample = False):\n", "\n", " if input_ids.device!=self.model.embedding.weight.device:\n", " input_ids = input_ids.to(self.model.embedding.weight.device)\n", "\n", " assert max_new_tokens>0\n", " assert temperature>0\n", "\n", " tokens_generated = 0\n", " while True:\n", " logits,loss = self.forward(input_ids)\n", " final_token_logits = logits[:,-1,:]\n", " if not sample:\n", " next_token = torch.argmax(final_token_logits) # Return the token with max prob\n", "\n", " #Sample from multinomial distribution with probabilities calculated from logits\n", " final_token_logits = final_token_logits/temperature # scale by temperature\n", " probs = nn.functional.softmax(final_token_logits, dim=-1)\n", " next_token = torch.multinomial(probs, num_samples=1)\n", "\n", " tokens_generated += 1\n", " input_ids = torch.cat((input_ids, next_token), dim=1) # Add next token ID to input_ids for generating further tokens\n", " # print(f'input ids shape {input_ids.shape[-1]}, {max_new_tokens}')\n", " if input_ids.shape[-1]>=min(self.max_len,max_new_tokens)-2:\n", " break\n", "\n", " del logits # delete the logits to save memory\n", "\n", " return input_ids.cpu().numpy()\n", " \n", " def configure_optimizers(self, weight_decay, learning_rate, betas, device_type):\n", " # start with all of the candidate parameters\n", " param_dict = {pn: p for pn, p in self.named_parameters()}\n", " # filter out those that do not require grad\n", " param_dict = {pn: p for pn, p in param_dict.items() if p.requires_grad}\n", " # create optim groups. Any parameters that is 2D will be weight decayed, otherwise no.\n", " # i.e. all weight tensors in matmuls + embeddings decay, all biases and layernorms don't.\n", " decay_params = [p for n, p in param_dict.items() if p.dim() >= 2]\n", " nodecay_params = [p for n, p in param_dict.items() if p.dim() < 2]\n", " optim_groups = [\n", " {'params': decay_params, 'weight_decay': weight_decay},\n", " {'params': nodecay_params, 'weight_decay': 0.0}\n", " ]\n", " num_decay_params = sum(p.numel() for p in decay_params)\n", " num_nodecay_params = sum(p.numel() for p in nodecay_params)\n", " print(f\"num decayed parameter tensors: {len(decay_params)}, with {num_decay_params:,} parameters\")\n", " print(f\"num non-decayed parameter tensors: {len(nodecay_params)}, with {num_nodecay_params:,} parameters\")\n", " # Create AdamW optimizer and use the fused version if it is available\n", " fused_available = 'fused' in inspect.signature(torch.optim.AdamW).parameters\n", " use_fused = fused_available and device_type == 'cuda'\n", " extra_args = dict(fused=True) if use_fused else dict()\n", " optimizer = torch.optim.AdamW(optim_groups, lr=learning_rate, betas=betas, **extra_args)\n", " print(f\"using fused AdamW: {use_fused}\")\n", "\n", " return optimizer\n", " \n", " def get_num_params(self):\n", " n_params = sum(p.numel() for p in self.parameters())\n", " return n_params\n" ] }, { "cell_type": "markdown", "metadata": { "id": "Uf4a_Fmnnxti" }, "source": [ "## Training Setup" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "id": "nrs3UvfBU47e" }, "outputs": [], "source": [ "def get_lr(it, warmup_iters, lr_decay_iters, min_lr, learning_rate):\n", " if it < warmup_iters:\n", " return learning_rate * it / warmup_iters\n", " # 2) if it > lr_decay_iters, return min learning rate\n", " if it > lr_decay_iters:\n", " return min_lr\n", " # 3) in between, use cosine decay down to min learning rate\n", " decay_ratio = (it - warmup_iters) / (lr_decay_iters - warmup_iters)\n", " assert 0 <= decay_ratio <= 1\n", " coeff = 0.5 * (1.0 + math.cos(math.pi * decay_ratio)) # coeff ranges 0..1\n", " return min_lr + coeff * (learning_rate - min_lr)\n", "\n", "@torch.no_grad()\n", "def run_model_and_get_loss(model, steps=100):\n", "\n", " model.eval()\n", " phase_wise_loss = {}\n", " for phase in ['train', 'val']:\n", " losses = []\n", " for _ in range(steps):\n", " input_ids, labels = get_data(phase)\n", " _, loss = model(input_ids, labels)\n", " losses.append(loss.item())\n", " phase_wise_loss[phase] = np.mean(losses)\n", " model.train()\n", "\n", " return phase_wise_loss['train'], phase_wise_loss['val']\n", "\n", "def train_model(model, optimizer, num_iters, device, accumulation_steps=1, eval_steps=100, lr_decay=False, batch_size=512, max_grad_norm=-1,train_dtype=torch.float32):\n", " \n", " train_losses = []\n", " val_losses = []\n", " model = model.to(device)\n", " \n", " warmup_iters = 100\n", " lr_decay_iters = num_iters\n", " min_lr = 1e-4\n", " start_lr = 1e-3\n", "\n", " scaler = GradScaler(enabled=(train_dtype!=torch.float32)) # to make sure grads are in FP32 even for BF/FP16 trainig\n", "\n", " inputs, labels = get_data('train', batch_size)\n", "\n", " for iter_num in tqdm(range(num_iters),'training'):\n", "\n", " start_time = time()\n", "\n", " lr = get_lr(iter_num, warmup_iters, lr_decay_iters, min_lr, start_lr) if lr_decay else start_lr\n", " for param_group in optimizer.param_groups:\n", " param_group['lr'] = lr\n", " \n", " for _ in range(accumulation_steps):\n", " with torch.autocast(dtype=train_dtype, device_type='cuda'):\n", " _, loss = model(inputs, labels)\n", " loss = loss / accumulation_steps\n", "\n", " scaler.scale(loss).backward()\n", " \n", " if max_grad_norm != -1:\n", " scaler.unscale_(optimizer)\n", " torch.nn.utils.clip_grad_norm_(model.parameters(), max_grad_norm)\n", "\n", " inputs, labels = get_data('train',batch_size)\n", "\n", " scaler.step(optimizer)\n", " scaler.update()\n", " optimizer.zero_grad(set_to_none=True)\n", "\n", " end_time = time()\n", " \n", " if (iter_num + 1) % eval_steps == 0:\n", " with torch.autocast(dtype=train_dtype, device_type='cuda'):\n", " train_loss, val_loss = run_model_and_get_loss(model)\n", " train_losses.append(train_loss)\n", " val_losses.append(val_loss)\n", "\n", " print(f'Iteration: {iter_num + 1}, Train Loss: {train_losses[-1]:.4f}, Val Loss: {val_losses[-1]:.4f}')\n", " \n", " plt.plot(train_losses, label='train_loss')\n", " plt.plot(val_losses, label='val_loss')\n", " plt.xlabel('Iterations')\n", " plt.ylabel('Loss')\n", " plt.legend()\n", " plt.title('Training and Validation Loss')\n", " plt.show()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Smol models" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "rJAiS4QlW401", "outputId": "a0e5dbef-7365-4cc5-eadd-ced2a4c6e918" }, "outputs": [ { "data": { "text/plain": [ "184832" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "nano_llama = NanoLlamaForCausalLM(n_layers=3, vocab_size=len(all_characters)+1, hidden_size=64, n_attn_heads=4, n_kv_heads=2, intermediate_size=256,max_len=block_size, residual=False, normalise=False)\n", "nano_llama.get_num_params()" ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "id": "CPrW_hHcNGU9" }, "outputs": [], "source": [ "nano_llama = nano_llama.to(device)\n", "nano_llama = torch.compile(nano_llama)" ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "id": "vgmf-3nL83db" }, "outputs": [], "source": [ "optimizer = torch.optim.AdamW(nano_llama.parameters(), lr=0.0001)\n", "criterion = nn.CrossEntropyLoss()" ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 522, "referenced_widgets": [ "0de38f17934040f3a760965e3ab869de", "e178916466d64e568a8abfcb797ec0cd", "cafff4a16c9b429eb4d024ef73149d56", "30a9f865abc94f89ae5c2e9fd5352214", "9b59ce324223413fb6b65cda2e075966", "6270f7fbf2974a22b2eadd6d162e4864", "96a704c174184da38c51dfc011ee0479", "5103b8685eda4259ac8cebba368b846c", "e4d1332c6299421d8086aeda0d8cc952", "dadcbf8da464400f90d19585974e4aee", "b79782127a264d2f92d0110773d614e7" ] }, "id": "-mOH_3UeUT1U", "outputId": "77f49585-4efa-4091-ebae-9379c759ebcf" }, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "c90612b17bff46d091c3084c4686f96f", "version_major": 2, "version_minor": 0 }, "text/plain": [ "training: 0%| | 0/1000 [00:00" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "train_model(nano_llama, optimizer, num_iters=1000,device=device)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Residual" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "![alt text](image.png)" ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "scrolled": true }, "outputs": [ { "data": { "text/plain": [ "184832" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "nano_llama = NanoLlamaForCausalLM(n_layers=3, vocab_size=len(all_characters)+1, hidden_size=64, n_attn_heads=4, n_kv_heads=2, intermediate_size=256,max_len=block_size, residual=True, normalise=False)\n", "nano_llama.to(device)\n", "nano_llama = torch.compile(nano_llama)\n", "nl_param_count = nano_llama.get_num_params()\n", "nl_param_count#, nano_llama" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "f6578bace72e4c8983d2f9a21e361edf", "version_major": 2, "version_minor": 0 }, "text/plain": [ "training: 0%| | 0/500 [00:00" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "optimizer = torch.optim.AdamW(nano_llama.parameters(), lr=0.0001)\n", "train_model(nano_llama, optimizer, num_iters=500,device=device)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Nomralise" ] }, { "cell_type": "code", "execution_count": 23, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "eE9QXDMU6Nu8", "outputId": "cb0c5b8f-a332-40c9-868f-d5c443fbe926" }, "outputs": [ { "data": { "text/plain": [ "184832" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "nano_llama = NanoLlamaForCausalLM(n_layers=3, vocab_size=len(all_characters)+1, hidden_size=64, n_attn_heads=4, n_kv_heads=2, intermediate_size=256,max_len=block_size, residual=False, normalise=True)\n", "nano_llama.to(device)\n", "nano_llama = torch.compile(nano_llama)\n", "nl_param_count = nano_llama.get_num_params()\n", "nl_param_count#, nano_llama" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "b86f54f97b7c4c30a0c200c2c8a898de", "version_major": 2, "version_minor": 0 }, "text/plain": [ "training: 0%| | 0/500 [00:00" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "optimizer = torch.optim.AdamW(nano_llama.parameters(), lr=0.0001)\n", "train_model(nano_llama, optimizer, num_iters=500,device=device)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Both" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "184832" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "nano_llama = NanoLlamaForCausalLM(n_layers=3, vocab_size=len(all_characters)+1, hidden_size=64, n_attn_heads=4, n_kv_heads=2, intermediate_size=256,max_len=block_size, residual=True, normalise=True)\n", "nano_llama.to(device)\n", "nano_llama = torch.compile(nano_llama)\n", "nl_param_count = nano_llama.get_num_params()\n", "nl_param_count#, nano_llama" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "5b6826fb85254310a1c4f6c2797513b7", "version_major": 2, "version_minor": 0 }, "text/plain": [ "training: 0%| | 0/500 [00:00" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "optimizer = torch.optim.AdamW(nano_llama.parameters(), lr=0.0001)\n", "train_model(nano_llama, optimizer, num_iters=500,device=device)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### max grad norm" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "184832" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "nano_llama = NanoLlamaForCausalLM(n_layers=3, vocab_size=len(all_characters)+1, hidden_size=64, n_attn_heads=4, n_kv_heads=2, intermediate_size=256,max_len=block_size, residual=True, normalise=True)\n", "nano_llama.to(device)\n", "nano_llama = torch.compile(nano_llama)\n", "nl_param_count = nano_llama.get_num_params()\n", "nl_param_count#, nano_llama" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "1091239b764c43e19171313a1430d375", "version_major": 2, "version_minor": 0 }, "text/plain": [ "training: 0%| | 0/1000 [00:00" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "optimizer = torch.optim.AdamW(nano_llama.parameters(), lr=0.0001)\n", "train_model(nano_llama, optimizer, num_iters=1000,device=device,max_grad_norm=1.0)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Does Higher intermediate size matter" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "35db7a566cbe43ed9fc2374582e19dab", "version_major": 2, "version_minor": 0 }, "text/plain": [ "training: 0%| | 0/1000 [00:00" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "094e260f7a1d454394eee03bfe67e170", "version_major": 2, "version_minor": 0 }, "text/plain": [ "training: 0%| | 0/1000 [00:00" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "a5382b461cc04dae90733648bda2697f", "version_major": 2, "version_minor": 0 }, "text/plain": [ "training: 0%| | 0/1000 [00:00" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "7523d47cd5a5432b91e9d110bf9d7b8c", "version_major": 2, "version_minor": 0 }, "text/plain": [ "training: 0%| | 0/1000 [00:00" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "9a95d281bf064f009c7321473686291e", "version_major": 2, "version_minor": 0 }, "text/plain": [ "training: 0%| | 0/1000 [00:00" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "for intermediate_size in [32,64,128,256,512]:\n", " nano_llama = NanoLlamaForCausalLM(n_layers=3, vocab_size=len(all_characters)+1, hidden_size=64, n_attn_heads=4, n_kv_heads=2, intermediate_size=intermediate_size,max_len=block_size, residual=True, normalise=True)\n", " nano_llama.to(device)\n", " nano_llama = torch.compile(nano_llama)\n", " nl_param_count = nano_llama.get_num_params()\n", " nl_param_count#, nano_llama\n", " optimizer = torch.optim.AdamW(nano_llama.parameters(), lr=0.0001)\n", " train_model(nano_llama, optimizer, num_iters=1000,device=device,max_grad_norm=1.0)" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "b2a0a38bd1c24eaaa90d5d4aee91b15b", "version_major": 2, "version_minor": 0 }, "text/plain": [ "training: 0%| | 0/1000 [00:00" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "a509fb51d6cd4572b5a1b724eeb71c7c", "version_major": 2, "version_minor": 0 }, "text/plain": [ "training: 0%| | 0/1000 [00:00" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "f31e96c5b1404df5ae6a04232ead0984", "version_major": 2, "version_minor": 0 }, "text/plain": [ "training: 0%| | 0/1000 [00:00" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "for intermediate_size in [1024,2048,4096]:\n", " nano_llama = NanoLlamaForCausalLM(n_layers=3, vocab_size=len(all_characters)+1, hidden_size=64, n_attn_heads=4, n_kv_heads=2, intermediate_size=intermediate_size,max_len=block_size, residual=True, normalise=True)\n", " nano_llama.to(device)\n", " nano_llama = torch.compile(nano_llama)\n", " nl_param_count = nano_llama.get_num_params()\n", " nl_param_count#, nano_llama\n", " optimizer = torch.optim.AdamW(nano_llama.parameters(), lr=0.0001)\n", " train_model(nano_llama, optimizer, num_iters=1000,device=device,max_grad_norm=1.0)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Onto Big Model" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "Dgv8Nza3BARd", "outputId": "f9c43ea5-439f-4dd7-8565-e09c257d64ce" }, "outputs": [], "source": [ "nano_llama_big = NanoLlamaForCausalLM(n_layers=12, vocab_size=128, hidden_size=512, n_attn_heads=16, n_kv_heads=8, intermediate_size=2048, residual=True, normalise=True)\n", "nl_param_count = nano_llama_big.get_num_params()\n", "nano_llama_big = torch.compile(nano_llama_big)\n", "nano_llama_big.to(device)\n", "print(f'Param count {nl_param_count} aka {nl_param_count/(10**6)} million params')" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 522, "referenced_widgets": [ "803e8c5bb65c4c77887c5cc16e51ab9c", "60193095d4964169a1575d697fed6ad6", "4435c469978c4b0d9d726c4686363c62", "5db8580eca95451e9fadfd6e0a10ec4f", "296f3088d0844528a45bf36e21961348", "a89c511b42964247a67e8c1348abb792", "e9ff09f027564edbb43801c6dca01eb6", "1197b685eacc4c2daf56e75e8dcf088b", "7388c6af930a40b887f13b2aef17b6b5", "0ce9c707c0ac4ebd8fac23c8f318bfd8", "36ce14d7573a4d8cb8379808e0d5552b" ] }, "id": "jQC0rXWXxllE", "outputId": "e7afe0d4-89b3-4a52-9886-ed9683dafb63" }, "outputs": [], "source": [ "with torch.amp.autocast(device_type='cuda', dtype=torch.bfloat16):\n", " torch.cuda.empty_cache()\n", " optimizer = nano_llama_big.configure_optimizers(0.1,0.001,(0.9,0.99),'cuda')\n", " train_model(nano_llama_big, optimizer, num_iters=2000,device=device, eval_steps = 200,lr_decay=True, batch_size = 64, max_grad_norm=1.0, train_dtype=torch.bfloat16)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 35 }, "id": "D87ILOfwxoZ7", "outputId": "00d8feab-a473-4d60-dda0-f6cfa48fdac4" }, "outputs": [], "source": [ "text = '\\n looking for clues. '\n", "encoded_text = encode(text)\n", "tensor_input = torch.tensor([encoded_text]).to(device).reshape(1,-1) # to adjust for the lack of batch\n", "out_tokens = nano_llama_big.generate(tensor_input, max_new_tokens=200,temperature=1)\n", "decoded_text = decode(out_tokens[0])\n", "print(''.join(decoded_text[len(text):]))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "random_nano_llama_big = NanoLlamaForCausalLM(n_layers=12, vocab_size=128, hidden_size=512, n_attn_heads=16, n_kv_heads=8, intermediate_size=2048, residual=True, normalise=True)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "decoded_text2" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from transformers import AutoModelForCausalLM, AutoTokenizer\n", "model = AutoModelForCausalLM.from_pretrained('/home/datta0/spt', trust_remote_code = True)\n", "tokenizer = AutoTokenizer.from_pretrained('/home/datta0/spt', trust_remote_code = True)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "accelerator": "GPU", "colab": { "gpuType": "T4", "provenance": [] }, "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.19" }, "widgets": { "application/vnd.jupyter.widget-state+json": { "state": {}, "version_major": 2, "version_minor": 0 } } }, "nbformat": 4, "nbformat_minor": 4 }