004_makemore_BatchNorm/BatchNorm_exercises.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "f9fd5d41",
   "metadata": {},
   "source": [
    "# makemore_BatchNorm\n",
    "\n",
    "----\n",
    "* Inspired by Andrej Karpathy's [\"Building makemore Part 3: Activations & Gradients, BatchNorm\n",
    "\"](https://www.youtube.com/watch?v=P6sfmUTpUmc)\n",
    "\n",
    "* Useful links \n",
    "    - [\"Kaiming init\" paper](https://arxiv.org/abs/1502.01852)\n",
    "    - [BatchNorm paper](https://arxiv.org/abs/1502.03167)\n",
    "    - Bengio et al. 2003 MLP language model paper [(pdf)](https://www.jmlr.org/papers/volume3/bengio03a/bengio03a.pdf)\n",
    "    - Good [paper](https://arxiv.org/abs/2105.07576) illustrating some of the problems with batchnorm in practice"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2db36255",
   "metadata": {},
   "source": [
    "-----\n",
    "<br><br>\n",
    "# Exercises\n",
    "----\n",
    "\n",
    "1. I did not get around to seeing what happens when you [initialize all weights and biases to zero.](#1) Try this and train the neural net. You might think either that \n",
    "* the network trains just fine or \n",
    "* the network doesn't train at all, but actually it is \n",
    "* the network trains but only partially, and achieves a pretty bad final performance. Inspect the gradients and activations to figure out what is happening and why the network is only partially training, and what part is being trained exactly.\n",
    "2. `BatchNorm`, unlike other normalization layers like `LayerNorm`/`GroupNorm` etc. has the big advantage that after training, the `batchnorm` `gamma`/`beta` can be \"folded into\" the weights of the preceding linear layers, effectively erasing the need to forward it at test time. \n",
    "    - Set up a [small 3-layer MLP with `batchnorms`](#2), \n",
    "    - train the network, \n",
    "    - then [\"fold\"](#202) the `batchnorm` `gamma`/`beta` into the preceding linear layer's `W`, `b` by creating a new `W2`, `b2` and erasing the batch norm. \n",
    "    - Verify that this gives the same forward pass during inference. i.e. we see that the `batchnorm` is there just for stabilizing the training, and can be thrown out after training is done! pretty cool.\n",
    "    \n",
    "----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "0ae4e52a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn.functional as F\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e048221a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['emma', 'olivia', 'ava', 'isabella', 'sophia', 'charlotte', 'mia', 'amelia']\n",
      "32033\n"
     ]
    }
   ],
   "source": [
    "words = open('../data/names.txt', 'r').read().splitlines()\n",
    "print(words[:8])\n",
    "print(len(words))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "19fa8b22",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 'a', 2: 'b', 3: 'c', 4: 'd', 5: 'e', 6: 'f', 7: 'g', 8: 'h', 9: 'i', 10: 'j', 11: 'k', 12: 'l', 13: 'm', 14: 'n', 15: 'o', 16: 'p', 17: 'q', 18: 'r', 19: 's', 20: 't', 21: 'u', 22: 'v', 23: 'w', 24: 'x', 25: 'y', 26: 'z', 0: '.'}\n",
      "27\n"
     ]
    }
   ],
   "source": [
    "chars = sorted(list(set(''.join(words))))\n",
    "stoi = {s:i+1 for i,s in enumerate(chars)}\n",
    "stoi['.'] = 0\n",
    "itos = {i:s for s,i in stoi.items()}\n",
    "vocab_size = len(itos)\n",
    "print(itos)\n",
    "print(vocab_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "8d636fb2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([182625, 3]) torch.Size([182625])\n",
      "torch.Size([22655, 3]) torch.Size([22655])\n",
      "torch.Size([22866, 3]) torch.Size([22866])\n"
     ]
    }
   ],
   "source": [
    "block_size = 3 \n",
    "\n",
    "def build_dataset(words):\n",
    "    X, Y = [], []\n",
    "\n",
    "    for w in words:\n",
    "        context = [0] * block_size\n",
    "        for ch in w + '.':\n",
    "            ix = stoi[ch]\n",
    "            X.append(context)\n",
    "            Y.append(ix)\n",
    "            context = context[1:] + [ix] \n",
    "\n",
    "    X = torch.tensor(X)\n",
    "    Y = torch.tensor(Y)\n",
    "    print(X.shape, Y.shape)\n",
    "    return X, Y\n",
    "\n",
    "import random\n",
    "random.seed(42)\n",
    "random.shuffle(words)\n",
    "n1 = int(0.8*len(words))\n",
    "n2 = int(0.9*len(words))\n",
    "\n",
    "Xtr,  Ytr  = build_dataset(words[:n1])     # 80%\n",
    "Xdev, Ydev = build_dataset(words[n1:n2])   # 10%\n",
    "Xte,  Yte  = build_dataset(words[n2:])     # 10%"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ed16fad",
   "metadata": {},
   "source": [
    "-----\n",
    "<a id=\"1\"></a>\n",
    "# 1. Initialize all weights and biases to $0$\n",
    "----\n",
    "## gamma = bn_gain, beta = bn_bias"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "f25f2d13",
   "metadata": {},
   "outputs": [],
   "source": [
    "gain = 5/3\n",
    "last_layer_scale_factor = 0.1\n",
    "\n",
    "batch_norm = False\n",
    "#fan_in_norm = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "02864285",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's train a deeper network\n",
    "# The classes we create here are the same API as nn.Module in PyTorch\n",
    "\n",
    "class Linear:\n",
    "\n",
    "    def __init__(self, fan_in, fan_out, bias=True):\n",
    "        if batch_norm:\n",
    "            self.weight = torch.zeros((fan_in, fan_out))\n",
    "        if not batch_norm:\n",
    "            self.weight = torch.zeros((fan_in, fan_out)) / fan_in**0.5\n",
    "        self.bias = torch.zeros(fan_out) if bias else None\n",
    "\n",
    "    def __call__(self, x):\n",
    "        self.out = x @ self.weight\n",
    "        if self.bias is not None:\n",
    "            self.out += self.bias\n",
    "        return self.out\n",
    "\n",
    "    def parameters(self):\n",
    "        return [self.weight] + ([] if self.bias is None else [self.bias])\n",
    "\n",
    "\n",
    "class BatchNorm1d:\n",
    "\n",
    "    def __init__(self, dim, eps=1e-5, momentum=0.1):\n",
    "        self.eps = eps\n",
    "        self.momentum = momentum\n",
    "        self.training = True\n",
    "        \n",
    "        # parameters (trained with backprop)\n",
    "        self.gamma = torch.ones(dim)\n",
    "        self.beta = torch.zeros(dim)\n",
    "        \n",
    "        # buffers (trained with a running 'momentum update')\n",
    "        self.running_mean = torch.zeros(dim)\n",
    "        self.running_var = torch.ones(dim)\n",
    "\n",
    "    def __call__(self, x):\n",
    "        # calculate the forward pass\n",
    "        if self.training:\n",
    "            xmean = x.mean(0, keepdim=True) # batch mean\n",
    "            xvar = x.var(0, keepdim=True) # batch variance\n",
    "        else:\n",
    "            xmean = self.running_mean\n",
    "            xvar = self.running_var\n",
    "        xhat = (x - xmean) / torch.sqrt(xvar + self.eps) # normalize to unit variance\n",
    "        self.out = self.gamma * xhat + self.beta\n",
    "        \n",
    "        # update the buffers in training\n",
    "        if self.training:\n",
    "            with torch.no_grad():\n",
    "                self.running_mean = (1 - self.momentum) * self.running_mean + self.momentum * xmean\n",
    "                self.running_var = (1 - self.momentum) * self.running_var + self.momentum * xvar\n",
    "        return self.out\n",
    "\n",
    "    def parameters(self):\n",
    "        return [self.gamma, self.beta]\n",
    "\n",
    "class Tanh:\n",
    "    def __call__(self, x):\n",
    "        self.out = torch.tanh(x)\n",
    "        return self.out\n",
    "    \n",
    "    def parameters(self):\n",
    "        return []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "280ca7a1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "46497\n"
     ]
    }
   ],
   "source": [
    "n_embd = 10 # the dimensionality of the character embedding vectors\n",
    "n_hidden = 100 # the number of neurons in the hidden layer of the MLP\n",
    "g = torch.Generator().manual_seed(2147483647) # for reproducibility\n",
    "\n",
    "C = torch.randn((vocab_size, n_embd),            generator=g)\n",
    "\n",
    "if batch_norm:\n",
    "    layers = [\n",
    "      Linear(n_embd * block_size, n_hidden, bias=False), BatchNorm1d(n_hidden), Tanh(),\n",
    "      Linear(           n_hidden, n_hidden, bias=False), BatchNorm1d(n_hidden), Tanh(),\n",
    "      Linear(           n_hidden, n_hidden, bias=False), BatchNorm1d(n_hidden), Tanh(),\n",
    "      Linear(           n_hidden, n_hidden, bias=False), BatchNorm1d(n_hidden), Tanh(),\n",
    "      Linear(           n_hidden, n_hidden, bias=False), BatchNorm1d(n_hidden), Tanh(),\n",
    "      Linear(           n_hidden, vocab_size, bias=False), BatchNorm1d(vocab_size),\n",
    "    ]\n",
    "if not batch_norm:\n",
    "    layers = [\n",
    "      Linear(n_embd * block_size, n_hidden), Tanh(),\n",
    "      Linear(           n_hidden, n_hidden), Tanh(),\n",
    "      Linear(           n_hidden, n_hidden), Tanh(),\n",
    "      Linear(           n_hidden, n_hidden), Tanh(),\n",
    "      Linear(           n_hidden, n_hidden), Tanh(),\n",
    "      Linear(           n_hidden, vocab_size),\n",
    "    ]\n",
    "\n",
    "with torch.no_grad():\n",
    "    # last layer: make less confident\n",
    "    if batch_norm:\n",
    "        layers[-1].gamma *= last_layer_scale_factor\n",
    "    if not batch_norm:\n",
    "        layers[-1].weight *= last_layer_scale_factor\n",
    "        \n",
    "    # all other layers: apply gain\n",
    "    for layer in layers[:-1]:\n",
    "        if isinstance(layer, Linear):\n",
    "            layer.weight *= gain   # default value: 5/3\n",
    "\n",
    "parameters = [C] + [p for layer in layers for p in layer.parameters()]\n",
    "print(sum(p.nelement() for p in parameters)) # number of parameters in total\n",
    "for p in parameters:\n",
    "    p.requires_grad = True\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "id": "82beb6c7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# same optimization as last time\n",
    "\n",
    "\n",
    "def train_model(Xtr, Ytr, C, layers, parameters, \n",
    "                max_steps = 200000, batch_size = 32, learn_rate=0.1):\n",
    "    lossi = []\n",
    "    ud = []    # update_to_date_ratio\n",
    "\n",
    "    for i in range(max_steps):\n",
    "\n",
    "        # minibatch construct\n",
    "        ix = torch.randint(0, Xtr.shape[0], (batch_size,), generator=g)\n",
    "        Xb, Yb = Xtr[ix], Ytr[ix] # batch X,Y\n",
    "\n",
    "        # forward pass\n",
    "        emb = C[Xb] # embed the characters into vectors\n",
    "        x = emb.view(emb.shape[0], -1) # concatenate the vectors\n",
    "        for layer in layers:\n",
    "            x = layer(x)\n",
    "        loss = F.cross_entropy(x, Yb) # loss function\n",
    "\n",
    "        # backward pass\n",
    "        for layer in layers:\n",
    "            layer.out.retain_grad() # AFTER_DEBUG: would take out retain_graph\n",
    "        for p in parameters:\n",
    "            p.grad = None\n",
    "        loss.backward()\n",
    "\n",
    "        # update\n",
    "        lr = learn_rate if i < (0.75 * max_steps) else 0.1 * learn_rate  # step learning rate decay\n",
    "        for p in parameters:\n",
    "            p.data += -lr * p.grad\n",
    "\n",
    "        # track stats\n",
    "        if i % (max_steps/20) == 0: # print every once in a while (lr = 20000)\n",
    "        #if i % (max_steps/10) == 0: # (lr = 100000)\n",
    "            print(f'{i:7d}/{max_steps:7d}: {loss.item():.4f}')\n",
    "\n",
    "        lossi.append(loss.log10().item())\n",
    "\n",
    "        with torch.no_grad():\n",
    "            ud.append([((lr*p.grad).std() / p.data.std()).log10().item() for p in parameters])\n",
    "\n",
    "    print(f\"training loss: {loss.item()}\")\n",
    "    return lossi, ud, layers, parameters, x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "id": "96bbf316",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_forward_activations(layers):\n",
    "    plt.figure(figsize=(12, 4)) # width and height of the plot\n",
    "    legends = []\n",
    "    for i, layer in enumerate(layers[:-1]): # note: exclude the output layer\n",
    "        if isinstance(layer, Tanh):\n",
    "            t = layer.out\n",
    "            print('layer %d (%10s): mean %+.2f, std %.2f, saturated: %.2f%%' % (i, layer.__class__.__name__, t.mean(), t.std(), (t.abs() > 0.97).float().mean()*100))\n",
    "            hy, hx = torch.histogram(t, density=True)\n",
    "            plt.plot(hx[:-1].detach(), hy.detach())\n",
    "            legends.append(f'layer {i} ({layer.__class__.__name__})')\n",
    "    plt.legend(legends)\n",
    "    plt.title('activation distribution')\n",
    "\n",
    "\n",
    "def plot_backward_gradients(layers):\n",
    "    plt.figure(figsize=(12, 4)) # width and height of the plot\n",
    "    legends = []\n",
    "    for i, layer in enumerate(layers[:-1]): # note: exclude the output layer\n",
    "        if isinstance(layer, Tanh):\n",
    "            t = layer.out.grad\n",
    "            print('layer %d (%10s): mean %+f, std %e' % (i, layer.__class__.__name__, t.mean(), t.std()))\n",
    "            hy, hx = torch.histogram(t, density=True)\n",
    "            plt.plot(hx[:-1].detach(), hy.detach())\n",
    "            legends.append(f'layer {i} ({layer.__class__.__name__})')\n",
    "        plt.legend(legends);\n",
    "    plt.title('gradient distribution')\n",
    "\n",
    "\n",
    "def plot_weights_gradients(parameters):\n",
    "    plt.figure(figsize=(12, 4)) # width and height of the plot\n",
    "    legends = []\n",
    "    for i,p in enumerate(parameters):\n",
    "        t = p.grad\n",
    "        if p.ndim == 2:\n",
    "            print('weight %10s | mean %+f | std %e | grad:data ratio %e' % (tuple(p.shape), t.mean(), t.std(), t.std() / p.std()))\n",
    "            hy, hx = torch.histogram(t, density=True)\n",
    "            plt.plot(hx[:-1].detach(), hy.detach())\n",
    "            legends.append(f'{i} {tuple(p.shape)}')\n",
    "    plt.legend(legends)\n",
    "    plt.title('weights gradient distribution')\n",
    "\n",
    "    \n",
    "def plot_weights_last_layer(parameters):\n",
    "    plt.figure(figsize=(12, 4))\n",
    "    legends = []\n",
    "\n",
    "    for i,p in enumerate(parameters):\n",
    "        t = p.grad\n",
    "\n",
    "        # neglect bias and batch norm parameters (weights only)\n",
    "        if p.ndim == 2:\n",
    "            print(f\"weight shape {tuple(p.shape)} | mean {t.mean().item():.5f} | std {t.std().item():.5f} | grad:data ratio {t.std() / p.std():.2e}\")\n",
    "            hy, hx = torch.histogram(t, density=True)\n",
    "            plt.plot(hx[:-1].detach(), hy.detach())\n",
    "            legends.append(f\"weight {i} ({p.shape})\")\n",
    "            \n",
    "        if i == len(parameters) - 1:\n",
    "            print(f\"last layer weight shape {tuple(p.shape)} | mean {t.mean().item():.5f} | std {t.std().item():.5f} | grad:data ratio {t.std() / p.std():.2e}\")\n",
    "            hy, hx = torch.histogram(t, density=True)\n",
    "            plt.plot(hx[:-1].detach(), hy.detach())\n",
    "            legends.append(f\"last layer: weight {i} ({p.shape})\")\n",
    "    plt.legend(legends)\n",
    "    plt.title(\"Weights Gradient distribution\")\n",
    "    \n",
    "    \n",
    "def plot_update_to_data_ratio(parameters, ud):\n",
    "    plt.figure(figsize=(12, 4))\n",
    "    legends = []\n",
    "    for i,p in enumerate(parameters):\n",
    "        if p.ndim == 2:\n",
    "            plt.plot([ud[j][i] for j in range(len(ud))])\n",
    "            legends.append('param %d' % i)\n",
    "    plt.plot([0, len(ud)], [-3, -3], 'k') # these ratios should be ~1e-3, indicate on plot\n",
    "    plt.legend(legends)\n",
    "    plt.title('update-to-data ratio over time')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "0f874399",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      0/  20000: 3.2958\n",
      "   1000/  20000: 2.7689\n",
      "   2000/  20000: 2.6577\n",
      "   3000/  20000: 2.8419\n",
      "   4000/  20000: 2.8023\n",
      "   5000/  20000: 2.8188\n",
      "   6000/  20000: 2.8556\n",
      "   7000/  20000: 2.7194\n",
      "   8000/  20000: 2.7612\n",
      "   9000/  20000: 2.7593\n",
      "  10000/  20000: 2.7882\n",
      "  11000/  20000: 2.7591\n",
      "  12000/  20000: 2.7606\n",
      "  13000/  20000: 2.8545\n",
      "  14000/  20000: 2.8490\n",
      "  15000/  20000: 2.9410\n",
      "  16000/  20000: 2.9307\n",
      "  17000/  20000: 2.7226\n",
      "  18000/  20000: 2.8905\n",
      "  19000/  20000: 2.9722\n",
      "training loss: 2.6480002403259277\n"
     ]
    }
   ],
   "source": [
    "zero_W_b_losses, zero_W_b_updates, zero_W_b_layers, zero_W_b_parameters, zero_W_b_logits = \\\n",
    "train_model(Xtr, Ytr, C, layers, parameters, max_steps = 20000, \n",
    "            batch_size = 32, learn_rate=0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "ca6a5111",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "layer 1 (      Tanh): mean +0.00, std 0.00, saturated: 0.00%\n",
      "layer 3 (      Tanh): mean +0.00, std 0.00, saturated: 0.00%\n",
      "layer 5 (      Tanh): mean +0.00, std 0.00, saturated: 0.00%\n",
      "layer 7 (      Tanh): mean +0.00, std 0.00, saturated: 0.00%\n",
      "layer 9 (      Tanh): mean +0.00, std 0.00, saturated: 0.00%\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_forward_activations(zero_W_b_layers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "6db8aa5e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "layer 1 (      Tanh): mean +0.000000, std 0.000000e+00\n",
      "layer 3 (      Tanh): mean +0.000000, std 0.000000e+00\n",
      "layer 5 (      Tanh): mean +0.000000, std 0.000000e+00\n",
      "layer 7 (      Tanh): mean +0.000000, std 0.000000e+00\n",
      "layer 9 (      Tanh): mean +0.000000, std 0.000000e+00\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_backward_gradients(zero_W_b_layers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "03912f06",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "weight   (27, 10) | mean +0.000000 | std 0.000000e+00 | grad:data ratio 0.000000e+00\n",
      "weight  (30, 100) | mean +0.000000 | std 0.000000e+00 | grad:data ratio nan\n",
      "weight (100, 100) | mean +0.000000 | std 0.000000e+00 | grad:data ratio nan\n",
      "weight (100, 100) | mean +0.000000 | std 0.000000e+00 | grad:data ratio nan\n",
      "weight (100, 100) | mean +0.000000 | std 0.000000e+00 | grad:data ratio nan\n",
      "weight (100, 100) | mean +0.000000 | std 0.000000e+00 | grad:data ratio nan\n",
      "weight  (100, 27) | mean +0.000000 | std 0.000000e+00 | grad:data ratio nan\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_weights_gradients(zero_W_b_parameters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "id": "5c84949d",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "weight shape (27, 10) | mean 0.00000 | std 0.00000 | grad:data ratio 0.00e+00\n",
      "weight shape (30, 100) | mean 0.00000 | std 0.00000 | grad:data ratio nan\n",
      "weight shape (100, 100) | mean 0.00000 | std 0.00000 | grad:data ratio nan\n",
      "weight shape (100, 100) | mean 0.00000 | std 0.00000 | grad:data ratio nan\n",
      "weight shape (100, 100) | mean 0.00000 | std 0.00000 | grad:data ratio nan\n",
      "weight shape (100, 100) | mean 0.00000 | std 0.00000 | grad:data ratio nan\n",
      "weight shape (100, 27) | mean 0.00000 | std 0.00000 | grad:data ratio nan\n",
      "last layer weight shape (27,) | mean 0.00000 | std 0.04007 | grad:data ratio 3.31e-02\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_weights_last_layer(zero_W_b_parameters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "91b80a9e",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_update_to_data_ratio(zero_W_b_parameters, zero_W_b_updates)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31cb6614",
   "metadata": {},
   "source": [
    "----\n",
    "\n",
    "**Comment:** The nonlinearity saturation is $\\boldsymbol{0\\%}$ which indicates that the layers are not learning/training. This is further supported by the gradients distribution being shrunk down to $\\boldsymbol0$. It seems like the model is not learning/training at all but from the weights last layer plot we see that the last layer's bias has learned even though the weights are still $\\boldsymbol{0}$. Overall the model isn't learning as evidenced in the update ratio plot.\n",
    "\n",
    "----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "id": "89fc8b02",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(20,10))\n",
    "plt.imshow(zero_W_b_logits.abs() > 0.97, cmap = 'gray', interpolation = 'nearest')\n",
    "plt.title(\"|h| > 0.99: white is True (saturated neurons), black is False\")\n",
    "plt.ylabel(\"← total 32 tensors →\", labelpad=20, fontdict={\"size\":15});"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 246,
   "id": "d2ab566d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Linear\n",
      "Tanh\n",
      "Linear\n",
      "Tanh\n",
      "Linear\n",
      "Tanh\n",
      "Linear\n",
      "Tanh\n",
      "Linear\n",
      "Tanh\n",
      "Linear\n"
     ]
    }
   ],
   "source": [
    "for layer in zero_W_b_layers:\n",
    "    print(layer.__class__.__name__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 247,
   "id": "26b43d04",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Linear\n",
      "non zero grad: tensor([-0.0162, -0.1324,  0.0117,  0.0151,  0.0248,  0.0570,  0.0039, -0.0230,\n",
      "         0.0342, -0.0797,  0.0126,  0.0223, -0.0018,  0.0289,  0.0804,  0.0047,\n",
      "         0.0046, -0.0299, -0.0375, -0.0272, -0.0064,  0.0141,  0.0110,  0.0041,\n",
      "         0.0030,  0.0112,  0.0107])\n",
      "\n",
      "param index of non zero grad: 11 / 11\n"
     ]
    }
   ],
   "source": [
    "count = 0\n",
    "for layer in zero_W_b_layers:\n",
    "    for param in layer.parameters():\n",
    "        #print(param.grad)\n",
    "        if param.grad.sum() > 0.0:\n",
    "            print(layer.__class__.__name__)\n",
    "            print(f\"non zero grad: {param.grad}\")\n",
    "            print()\n",
    "            print(f\"param index of non zero grad: {count} / {len(zero_W_b_layers)}\")\n",
    "        count += 1   "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a3ca50c",
   "metadata": {},
   "source": [
    "-----\n",
    "<a id=\"2\"></a>\n",
    "# 2.  MLP3 (3-Layer MLP)\n",
    "----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 250,
   "id": "3b7cfec8",
   "metadata": {},
   "outputs": [],
   "source": [
    "gain = 1\n",
    "last_layer_scale_factor = 0.1\n",
    "\n",
    "batch_norm = True\n",
    "#fan_in_norm = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 251,
   "id": "5d6b3fbe",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's train a deeper network\n",
    "# The classes we create here are the same API as nn.Module in PyTorch\n",
    "\n",
    "class Linear:\n",
    "\n",
    "    def __init__(self, fan_in, fan_out, bias=True):\n",
    "        if batch_norm:\n",
    "            self.weight = torch.randn((fan_in, fan_out), generator=g)\n",
    "        if not batch_norm:\n",
    "            self.weight = torch.randn((fan_in, fan_out), generator=g) / fan_in**0.5\n",
    "        self.bias = torch.zeros(fan_out) if bias else None\n",
    "\n",
    "    def __call__(self, x):\n",
    "        self.out = x @ self.weight\n",
    "        if self.bias is not None:\n",
    "            self.out += self.bias\n",
    "        return self.out\n",
    "\n",
    "    def parameters(self):\n",
    "        return [self.weight] + ([] if self.bias is None else [self.bias])\n",
    "\n",
    "\n",
    "class BatchNorm1d:\n",
    "\n",
    "    def __init__(self, dim, eps=1e-5, momentum=0.1):\n",
    "        self.eps = eps\n",
    "        self.momentum = momentum\n",
    "        self.training = True\n",
    "        \n",
    "        # parameters (trained with backprop)\n",
    "        self.gamma = torch.ones(dim)\n",
    "        self.beta = torch.zeros(dim)\n",
    "        \n",
    "        # buffers (trained with a running 'momentum update')\n",
    "        self.running_mean = torch.zeros(dim)\n",
    "        self.running_var = torch.ones(dim)\n",
    "\n",
    "    def __call__(self, x):\n",
    "        # calculate the forward pass\n",
    "        if self.training:\n",
    "            xmean = x.mean(0, keepdim=True) # batch mean\n",
    "            xvar = x.var(0, keepdim=True) # batch variance\n",
    "        else:\n",
    "            xmean = self.running_mean\n",
    "            xvar = self.running_var\n",
    "        xhat = (x - xmean) / torch.sqrt(xvar + self.eps) # normalize to unit variance\n",
    "        self.out = self.gamma * xhat + self.beta\n",
    "        \n",
    "        # update the buffers in training\n",
    "        if self.training:\n",
    "            with torch.no_grad():\n",
    "                self.running_mean = (1 - self.momentum) * self.running_mean + self.momentum * xmean\n",
    "                self.running_var = (1 - self.momentum) * self.running_var + self.momentum * xvar\n",
    "        return self.out\n",
    "\n",
    "    def parameters(self):\n",
    "        return [self.gamma, self.beta]\n",
    "\n",
    "class Tanh:\n",
    "    def __call__(self, x):\n",
    "        self.out = torch.tanh(x)\n",
    "        return self.out\n",
    "    \n",
    "    def parameters(self):\n",
    "        return []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 252,
   "id": "563b9378",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16424\n"
     ]
    }
   ],
   "source": [
    "n_embd = 10 # the dimensionality of the character embedding vectors\n",
    "n_hidden = 100 # the number of neurons in the hidden layer of the MLP\n",
    "g = torch.Generator().manual_seed(2147483647) # for reproducibility\n",
    "\n",
    "C = torch.randn((vocab_size, n_embd),            generator=g)\n",
    "\n",
    "if batch_norm:\n",
    "    layers = [\n",
    "      Linear(n_embd * block_size, n_hidden, bias=False), BatchNorm1d(n_hidden), Tanh(),\n",
    "      Linear(           n_hidden, n_hidden, bias=False), BatchNorm1d(n_hidden), Tanh(),\n",
    "      Linear(           n_hidden, vocab_size, bias=False), BatchNorm1d(vocab_size),\n",
    "    ]\n",
    "if not batch_norm:\n",
    "    layers = [\n",
    "      Linear(n_embd * block_size, n_hidden), Tanh(),\n",
    "      Linear(           n_hidden, n_hidden), Tanh(),\n",
    "      Linear(           n_hidden, n_hidden), Tanh(),\n",
    "      Linear(           n_hidden, n_hidden), Tanh(),\n",
    "      Linear(           n_hidden, n_hidden), Tanh(),\n",
    "      Linear(           n_hidden, vocab_size),\n",
    "    ]\n",
    "\n",
    "with torch.no_grad():\n",
    "    # last layer: make less confident\n",
    "    if batch_norm:\n",
    "        layers[-1].gamma *= last_layer_scale_factor\n",
    "    if not batch_norm:\n",
    "        layers[-1].weight *= last_layer_scale_factor\n",
    "        \n",
    "    # all other layers: apply gain\n",
    "    for layer in layers[:-1]:\n",
    "        if isinstance(layer, Linear):\n",
    "            layer.weight *= gain   # default value: 5/3\n",
    "\n",
    "parameters = [C] + [p for layer in layers for p in layer.parameters()]\n",
    "print(sum(p.nelement() for p in parameters)) # number of parameters in total\n",
    "for p in parameters:\n",
    "    p.requires_grad = True\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 253,
   "id": "0c1fbcab",
   "metadata": {},
   "outputs": [],
   "source": [
    "# same optimization as last time\n",
    "\n",
    "\n",
    "def train_model_no_lr_decay(Xtr, Ytr, C, layers, parameters, \n",
    "                max_steps = 200000, batch_size = 32, learn_rate=0.1):\n",
    "    lossi = []\n",
    "    ud = []    # update_to_date_ratio\n",
    "\n",
    "    for i in range(max_steps):\n",
    "\n",
    "        # minibatch construct\n",
    "        ix = torch.randint(0, Xtr.shape[0], (batch_size,), generator=g)\n",
    "        Xb, Yb = Xtr[ix], Ytr[ix] # batch X,Y\n",
    "\n",
    "        # forward pass\n",
    "        emb = C[Xb] # embed the characters into vectors\n",
    "        x = emb.view(emb.shape[0], -1) # concatenate the vectors\n",
    "        for layer in layers:\n",
    "            x = layer(x)\n",
    "        loss = F.cross_entropy(x, Yb) # loss function\n",
    "\n",
    "        # backward pass\n",
    "        for layer in layers:\n",
    "            layer.out.retain_grad() # AFTER_DEBUG: would take out retain_graph\n",
    "        for p in parameters:\n",
    "            p.grad = None\n",
    "        loss.backward()\n",
    "\n",
    "        # update\n",
    "        lr = learn_rate #learn_rate if i < (0.75 * max_steps) else 0.1 * learn_rate  # step learning rate decay\n",
    "        for p in parameters:\n",
    "            p.data += -lr * p.grad\n",
    "\n",
    "        # track stats\n",
    "        #if i % (max_steps/20) == 0: # print every once in a while (lr = 20000)\n",
    "        if i % (max_steps/10) == 0: # (lr = 100000)\n",
    "            print(f'{i:7d}/{max_steps:7d}: {loss.item():.4f}')\n",
    "\n",
    "        lossi.append(loss.log10().item())\n",
    "\n",
    "        with torch.no_grad():\n",
    "            ud.append([((lr*p.grad).std() / p.data.std()).log10().item() for p in parameters])\n",
    "\n",
    "    print(f\"training loss: {loss.item()}\")\n",
    "    return lossi, ud, layers, parameters, x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 254,
   "id": "c1acf752",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      0/ 100000: 3.3138\n",
      "  10000/ 100000: 2.8430\n",
      "  20000/ 100000: 2.5132\n",
      "  30000/ 100000: 2.2348\n",
      "  40000/ 100000: 2.3918\n",
      "  50000/ 100000: 2.1464\n",
      "  60000/ 100000: 1.8751\n",
      "  70000/ 100000: 2.1717\n",
      "  80000/ 100000: 2.5002\n",
      "  90000/ 100000: 1.9719\n",
      "training loss: 2.3254995346069336\n"
     ]
    }
   ],
   "source": [
    "MLP3_losses, MLP3_updates, MLP3_layers, MLP3_parameters, MLP3_logits = \\\n",
    "train_model(Xtr, Ytr, C, layers, parameters, max_steps = 100000, \n",
    "            batch_size = 32, learn_rate=0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 255,
   "id": "e39d3b69",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(torch.tensor(MLP3_losses).view(-1, 1000).mean(1));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 256,
   "id": "858d98c4",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "layer 2 (      Tanh): mean -0.06, std 0.68, saturated: 9.03%\n",
      "layer 5 (      Tanh): mean +0.03, std 0.68, saturated: 9.47%\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_forward_activations(MLP3_layers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 257,
   "id": "761443d1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "layer 2 (      Tanh): mean +0.000000, std 6.916019e-03\n",
      "layer 5 (      Tanh): mean +0.000000, std 5.717656e-03\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_backward_gradients(MLP3_layers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 258,
   "id": "b2aed735",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "weight   (27, 10) | mean -0.000000 | std 1.541226e-02 | grad:data ratio 1.445028e-02\n",
      "weight  (30, 100) | mean -0.000088 | std 4.815627e-03 | grad:data ratio 4.661902e-03\n",
      "weight (100, 100) | mean +0.000007 | std 2.178752e-03 | grad:data ratio 2.181285e-03\n",
      "weight  (100, 27) | mean +0.000041 | std 3.628002e-03 | grad:data ratio 3.524541e-03\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_weights_gradients(MLP3_parameters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 259,
   "id": "381839df",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAssAAAEICAYAAACpnLlcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nOydd3gURR/Hv5NLIx2SQAgt9N5DAOm9idgVrAgqivqioi8KIl2kiFSVohSlSpPeew0BAqGEVJKQnpDeLrl9/5jdvd273SspJPjO53ny5G7L7Oze7s53fmWGcBwHBoPBYDAYDAaDYYxNZVeAwWAwGAwGg8GoqjCxzGAwGAwGg8FgqMDEMoPBYDAYDAaDoQITywwGg8FgMBgMhgpMLDMYDAaDwWAwGCowscxgMBgMBoPBYKjAxDKDwXiqIIS8Swg5X9n1KC2EED9CCEcIsa3sulgKIeQOIaRvZdejrBBCcgghjSq7HgwG4+mCiWUGg/GvhRAygxDyZxnL4AghTcqrTlYeuy8hJO4JH3M9IWSOdBnHca05jjv9JOtRVgghpwkh46XLOI5z4TgusrLqxGAwnk6YWGYwGIz/E54ma7Y1EEI0lV0HBoPx74WJZQaDUeEYWmel1kvBekoI+ZYQkkoIiSaEvCHZ1pMQ8g8hJIsQchVAY4OylxJCYvn1QYSQXvzyoQC+BfAa734P5pe7E0LWEUISCCGPCCFz1MQWIeQs/zGYL+M1fvn7hJBwQkg6XzdfE+euIYQs4s8tEsAIg/VjCSH3CCHZhJBIQsiH/HJnAIcA+PLHziGE+BJCAgghlwghGfw5rCCE2KscWwj5GEcIiQFwkl++gxCSSAjJJIScJYS05pd/AOANAF/zx9vHL48mhAzkPzsQQn4mhMTzfz8TQhxUjm9DCJlGCHlICEkmhGwkhLjz6w4RQj4x2D6YEPIi/7kFIeQYf41DCSGvSrZbTwj5hRBykBCSC6CfQTlzAfQCsII/jxX8cvE+5MtYxdcjhxBygRDiw5/PY0LIfUJIR0mZvoSQnYSQFEJIFCHkM7XfnMFg/LtgYpnBYFQFfAB4AagD4B0Aqwkhzfl1KwEUAKgN4D3+T0oggA4AagDYDGAHIcSR47jDAOYB2Ma739vz268HUAygCYCOAAYDGA8FOI7rzX9sz5exjRDSH8APAF7l6/QQwFYT5/Y+gGf5Y/kDeNlgfTK/3g3AWABLCCGdOI7LBTAMQDx/bBeO4+IBlAD4nL9e3QEMAPCxieMDQB8ALQEM4b8fAtAUQE0A1wH8xZ/vav7zAv54IxXKmgqgG+g1bw8gAMA0leO+y//1A9AIgAuAFfy6LQBGCxsSQloBaADgAN9ROAb6e9YE8DqAVfw2AmMAzAXgCkAWw85x3FQA5wB8wp+HTJRLeJWvuxeAQgCX+OvhBeBvAD/xdbMBsA9AMOg9OgDAJELIEIUyGQzGvwwmlhkMRlXhO47jCjmOOwPgAIBXeYvvSwCmcxyXy3FcCIAN0p04jvuT47g0juOKOY5bDMABQHOj0gEQQmoBGA5gEl9eMoAloGLMUt4A8DvHcdc5jisE8A2A7oQQP5XtXwXwM8dxsRzHpYMKbWn9D3AcF8FRzgA4CmoVVYTjuCCO4y7z5xsN4DdQMWyKGfz55vNl/M5xXDZf/xkA2gsWXwt4A8AsjuOSOY5LATATwFsmtv2J47hIjuNyQK/V64SGg+wG0IEQ0kCy7S6+Ts8CiOY47g/+PG8A2AngFUnZezmOu8BxnI7juAIL627Ibv56FvD1KeA4biPHcSUAtoF2cACgCwBvjuNmcRxXxMc9r4F19w2DwXhKYWKZwWBUBR7zllSBhwB8AXgDsAUQa7BOhBAymQ9jyCSEZABwB7UMKtEAgB2ABD6MIQNUbNbky7ojCXlQE6y+0jrwIjANQB1CSC/J/nck25uq/zBCyGU+3CADVMyr1R+EkGaEkP18GEUWqPVcdXse8fh8WMh8QkgEv380v8pcGQKy84f+t7J0W1sAtTiOywbtFAmCczR4Czfo79RV+I346/IGqAfC6JzKQJLkc77CdxdJfXwN6vMtgFrlUAcGg1HF+VcmezAYjCpHHgAnyXcfANJRHqoTQpwlgrk+gBAAKaAhE/UA3JesAwDwgvZrULf4HY7jdISQxwAIvwlnUI9YUHe7F8dxxYaV5DiutQXnEg8qnoQ6OAPwBPCIt/S6GGyfwNdfQFp/B1CL6dugllItIWSPifoDwC8AbgAYzXFcNiFkEoxDOwyRljMGwCgAA0GFsjsAU9fMEOH8hc5AfX6ZqW0h2bYYelG6BcD3hMaGOwI4xS+PBXCG47hBJuphrp7m1ltDLIAojuOalmOZDAbjKYFZlhkMxpPgJoAxvFVzKJTDBmYSQux5AfwsgB28O3wXgBmEECc+ZvUdyT6uoOIrBYAtIWQ6aOyvQBIAPz7mFBzHJYCGOSwmhLjxCWiNCSGmwhiSQONtBbYAGEsI6cCL3XkArvBCWYntAD4jhNQlhFQHMEWyzh40bCQFQDEhZBhoDLX02J4GIRKuALIA5BBCWgD4yETdlXAF7TCkgXZg5hmsNzxfQ7YAmEYI8SaEeAGYDkBteL4tAD4nhDQkhLhAH0MudFQOgorpWfxyHb98P4BmhJC3CCF2/F8XQkhLK87T3HlYw1UA2YSQ/xJCqvH3cRtCSJdyKp/BYFRhmFhmMBhPgv8AGAlAcKfvMVifCGrdjAd1xU/gOE6wJH8Caq1NBE3O+0Oy3xEAhwE8AHXxF0Dunt/B/08jhFznP78NKlLv8sf8GzRRT40ZADbw7vdXOY47DuA7UItwAujoHKZiV9fw9QwGTR7bJazgQxE+AxXUj0Gtvv9I1t8HFZyR/PF9AUzmt8vmy95m4thKbAS9Vo9Ar8Flg/XrALTij2f4OwHAHADXANwCcJs/pzkK2wHA7wA2ATgLIAr09/lUcn6FoNdjIGgyn7A8G7TT8DroPZEI4EfQjoWlLAXwMj+yxTIr9jOC77Q9C5rUGAUgFcBaUKs8g8H4l0M4rjw9VQwGg2EdhM4M9yfHcXUruy4MBoPBYBjCLMsMBoPBYDAYDIYKTCwzGAwGg8FgMBgqsDAMBoPBYDAYDAZDBWZZZjAYDAaDwWAwVKiy4yx7eXlxfn5+lV0NBoPBYDAYDMa/nKCgoFSO47yV1lVZsezn54dr165VdjUYDAaDwWAwGP9yCCEP1daxMAwGg8FgMBgMBkMFJpYZDAaDwWAwGAwVmFhmMBgMBoPBYDBUYGKZwWAwGAwGg8FQgYllBoPBYDAYDAZDBSaWGQwGg8FgMBgMFZhYZjAYDAaDwWAwVGBimcFgMBgMCzgXloKHabmVXQ0Gg/GEYWKZwWAwGAwLeGvdVfRZeLqyq8FgPHHSc4twJz6zsqtRaTCxzGAwGIz/K+Iz8vEoI7+yq8FQ4Vp0OtacjazsajAkjFx+HiOWna/salQaTCwzGOVA2++PYNXp8MquRqVSouNwMzajsqvBYJjlmfkn0WP+SaPllyLS0PPHk8gvKqmEWjEEXv71EuYevFfZ1Xgi5BQWo92MIzgXllLZVTHJ/3vnkollBqMcyC4sxoLDoZVdjUpl1alwPL/yAoIeplf4seIz8pFTWFzhxxHYGRSHU6HJT+x4jMph7sG7iHucj7Dk7MquihHJWQXgOK6yq8EoB0ITs5GeWyR+ziooxk/HHlRyrRimYGKZwWBYTXaB1mjZ/UQqMBIyCyr8+M/MP4lRK56cS/DLHcEY+0fgEzueEpl5Wny/NwSFxczqWVHYEAIAEDTpuvNRuBieWok1ojxIykbAvBNYfzH6iRzPf84x/HDo/8OyWxkM+fkshvx8trKrUSr+XxNcmVhmMBhWcTgkEW1nHMX1mMeK65+U8Ssi5f/rpb3gyH1suPQQe248quyqVCm+2xOC3TfiyqUswv/X8Tfx7P13MWbtlXIp2xJ0Og6/nYlAroHXJJK/1y9GpD2ReqTmFOG3MxUfM6wt0WHX9TjRYp6WU4h7CVkVftyywnEc1pyNRJai0SALj3mrsSlSsgsromoVjiUJrq/+dgn/BMdXfGWeIEwsMxhPGdoSHUp0leeOvRhBLW23DOKTeaMcmKPYPKdDkxFupatf+M2VfvrhS8+h94JTparL4ZBEJGVVvDegoth0+SE+3xaM7/eGwG/KgTKVRQTLsgXbBj1Mx8n7SWU6niGHQhLxw6H7WHD4vrisuEQnincborZn2cjM06JA++Q9FqtOReCL7cHYdysBALW4Dlt6zupylhx7gON3rf8tZvxzB6fuy8OrgmMzcPB2gmxZiY6DtkQnfj8fnoq5B+9h+p4QozKH/nwOzy439npl5BXhfJjcSxGamC3+toacC0uRHdMa/KYcwNTdt8XveUXFyMgzL+ClpOUUmvWqZOZr4TflAPbelHfgr0al47MtNyw6ToG2BA+Sql7YkyFMLDMY5ciOa7EVWn5GXhGaTj2Ed/+4atV+aTmFFjWGqTmFiEjJMbmNufZasBJdikjDoiOVH8d9KjTZbEO68lQ4us07YXXZHMeZvV5KvPtHIAb+VH5u2LsJWYhJz7No2/TcItFyWVyiw4Q/g/Dab5cA0PCa1JwnY/HaHhiLmfvuyJY9ysjHm2uvKIb5GJJTWIxkicjfcOmhRcc11dEUO3wWuEde+uUS3lt/zWi5Tsdh1elwo3O4GJ5q9hnM59dnF+gty02mHsLHf10HoA8TEcgq0CK3sBjbA2NxyQKrc0p2IUatvGDUOWo/6yhGr7kMAE9UNAv3miDkUnOsE3QCS0+EYfxG499CoETHYf2FKKMQpvUXozF2PQ2v0pboEJOWh1ErL4jXW2Ds+kA0nXpI/F6opSJW+jtJEZLhYtLyxGftvfWBeHPdFZnXYMjPZ/HKr5dk9bwVl4HA6HS8te4qFh8tfRzzX1dixM9Dfz6HDrOOWbX/mDVXMGbtFXAch7wi5fMUQjLWnotSXG/KC5aeW4TdN+Lw5Y5gDF5yFgmZ+ei36DRuqHgsKxsmlhlVFm2JDj8dDTVySVZlfjiktwjpSmH9vROfiWDeYlui42QN1+4bceIL71yYdXGUneccx5sK7uTnV17AB5JGpveCUxiw+IxFZQbHZcoan/28dehaNH3ZjV5zGStO0RFCiop1SM62znqpM7DmKLHiZJhZa+LYPwIVG9KFR+7Db8oBxGfkY+GRUCRaYF19YdUF2fc9Nx9hwOIzOM0n/+26HlfqmL5bcRmyJEKO4/D7+Siz7lprk746zT6GAYvPILewWLSgxj6mjXuvBafgP+e4bPttgTHoOOtoqe5nNQq0Jfh65y38cSFadn4/HX2A8+GpOBSSaLaMYUvPIsDKDk5aTiEaf3tQ/N5rwUl0mq0XEYIUTcoqXYdhZ1AcfjxyHwsOh6LPwtOIe0w7MBEpORiz9gre33gNd+OzcOp+MmIVOjfmOqKHQhKRmFmA23F0vNt2M46i46xj+HrnLVHsKlGi4+A35QC6zD2O4NgM/H4+yqjTcCMmA+M3BKLFd4clyx6rhltZQ4G2BKtOh6OoWIdJW2/Ab8oBzD90X7SUq3VgrBXuEzYFKVr7dwbFYca+uxi5/LzYwcrMk3dmpu+9g94Ljb0z2wJjcPYBHanCb8oBtJ1xBEH8NTlx33TSb++Fp9D6+yMAgLBk2qkuLlF/jpadCMNzKy5gWyA1uvx6JgLJWQXIyCtCIp8L8uflhzKrMQDEpucpdnKL+fen0JHmOA4n7iWJz/I/wfG4HJmGaXtuG4WOhPLWXo4DWk0/olhfc6+eSdtuIpw/77CkbNm76qM/g/D5tmAc4NuNc2GpiErNxcIqYGBRgollhkm2Xo3B9gq2lqqx63oclp0MN5klnFdUjP23KiY26mJ4qtijzszXWuQSExq7nUFxaPTtQcUGUUphcQkWHQkVjzNi2XmMWkkF2cd/BckaLiWBnJRVAL8pB3Al0rxV6dpD40bvZmwGjkqsrnn8kFn9F53GpssPFYWa4KrefeMRPtlMGz7pCBibLhtb+D7ZfB0Bc60TNlN23RKtOYXFJcjMN7Y2LpJYXkIeZVocnvI4twgrT0UAoGEIArHpeSjQlmDvzUdoNu0QAqPlI3vciKEdmb+D4hCWlI3bcTS+UmgQvtgejGdLORbpcysuyJIIHyTlYNb+u/h0y3VM3hEsHtuQ99Zbn3iYmFWA1t8fwYx/5JbdjDzjazx1dwge52lRwnGITMnBkTvmhWxgdLrYuEuJz8jHJ5uvy2I9V54KF79zvHxXEo234zLFxnbMmsuITVceymrvzUfIyCvCgVsJRp0bw+GvYtPzxVEJACAknv6ehpZFS/lyR7AY65ueWySGFGTx9+65sFQMX3YOY9cHYuBPZ1BcorN6mLpeC05ipCS5tUjyXlJ6RsKTc2QdBAD47WwkusylnSLp+/X4Pbn4e2HVRby46iIA4O3fr+Ka5Hk4HJKI+Ix8/HI6An5TDhh12iJScnA4JAEhjzLR4rvDWHA4FM2mHcKem/R9/euZCNjwalnHQfF+mXtAnmS49+YjmTfBkMN3EhWt/cL99SApB6PXXMbxu0loP+uobBu1oduWn5QPCZpdUIxfTkeo1kEJjuNEKzRnIsgn5BHtBP0dpI/Bn7nvLrr9cALdfjiBzVdiMG1PCP66EoOdQXHi9kInNzg2Q9YJWHtebvGduPk6xm24hs1XqdX5sy038Prqy/jzcgzmSww9UoosafcIcOZBCvYpxCkXFpfgYngqBi05C/85x/HSLxdpmxUlf7d+/fcts8epTGwruwKMqs2UXbQH+6p/vSd+7MJiHf9fvTERerz1qjuhfT0Ps2XejM1AaGIWXutSX3F9doEWTva2iM/IFxN7on4YjvYz6Yv17qwhcLKnj82sfXcRk56LmaPaiPsLXlIhuSE8OQf1ajiJ67V8/KGDrQYA0HwaFcNFJTqjuK0jd8zH4F3lXzgbLz9E10aeZrfPyCtCh1nH4Opoi9szhojLI1Jy4OZoJ36PTM3Fd3tCsPT4A3SqXx3zXmwLLxcHZBdoZRn5x3ih/dIvelciADT8Rm/tlVp+A6PT4V7NDs1quRrV7a8rD6Et1uHdHg0BANuv6RuM1367jJuxGYieP0LxvO7EZ+LZ5efxaf8m+HJwc7PXQatTbgB6GcT9vvLrJXw+sJlsmfR8xvbwMyoju7AYOYXFSMjIR0pOIRIzC/Bip7pm6yRQXKKDrcYGRfz9/zAtD5cjlYfjO3Y3CadC1cdnzSrQovPsY1j9tj/6Na9ptF5w1RoKnajUXKw8FY72dd3FZStPhePn42EAoPo73I3PQkZ+EcasuQIXB1uEzBwiW//uH1fxICkHvZt6i8vWX4zG+ovRWDmmE3Zdp25boUOWkl2IrAItkrMKMXrNZXw5qBk+HdDUZKLbf7behJeLg5GlLb+oRNUSFp2aCz8vZ/GaG8JxnPg+MqSoWAd7W2W7U3ZBMXQ6DnGPjYV9YbEOTfjO4DfDWuDDPo1RYMFIJ1oTlsn2M4+Kv03Qw3RUd7LHO78rh2yl5xZh+7VYLDsRZvaYQ5acRWhSNs4+SEHg1IHwdnXAhD+DUMvNQbTCFxbr8PKvFzFjZGt8uuWGOCpOY29n1XIFcT97/13M3n/XaL3U25NVoMV/tt5ECx9XHJ7UGwBwOTINUanWeXIiUnLxvUEnEVC3biv9dkqcup+MHk28xO/S94TgdQNgMhxC6Vx0HIcCPuzjW4lF+csdwQCAFzvWEZeNWnkBDpJ7cf6h+5jQp7H4/eBt2tGd8c8dvNmtgew4Wp1OrLP0+X5sItZZesWE+2xke1/ZNkuOheFKFH1e03KLkGYm+ZFUUFx+WWFimVEubL4SAy8Xewxu7VNuZQoNGzHrnITFcZbP81ZbJbFcouPQdsZRjA6oh6FtaovLA6P1FtmL4WkY2KoWAOD3C7TX7ucp7b3TuuqT3fikLB2HPG0JRi4/j6jUXCOxkV9UgtMmRI8agjUglB+27VRoMtZfiMZvb3WGo53GaHuhAcsuKJZZTdVCL1JzinD0bhLq1XDCd8+2UrU+GKImSoT4POn534nPRJOaLpi6mybLCGJZ4G58ljjZSX5RiawxEBBiMAVLi7ZEJ4sxBGhjG5eej1a+bsgr1IuSWQqNtJQlx9U9G0IjGJ6cI7OMvfv7VZkl35RY3ngpGtP36hvvbj+cwO6Pe6CEv4hqQ/ElZObjfYPwkhdWXcDuj3uI32/HZUJbwmHsH4GInj8CZx4o32M6Tt6491t0GoDcwiUIZYDG5ndr5Inj95LwICkbP7zYDkfvJOKDTUHiNjmFxYjPyMfEzdex7p0uqOFsjwdJfHy3wiM9cbPemjt5RzAm82JAyuJjD4waeSUM3we7rsfhi+3B6NXUS3H7vvz5SvlKcvyG38gts89JLLsfbrqGP8YGqNblm123sc2Md+6HQ/dlIVwP0/OQV1SMzZK4U0PUwmJOhybDz9PZqAOrhKXWvFBJR77L3OM49J9eAOThKoIXbNqeENk9a2rUmhP3TIcxHLubhAO3EjCsjQ9K+E6CMERlXlExXl+tHHoSHJuB9vU88OuZCHhUszNKojP0MBy/m2T0nCVnF6jGJEuxJKn0UwuT3SIVxLK5kKRdBnHBhp26mDRj72axwr2TJokXXyp51oebSLiMV5ioxHByruP3rEu8vBCehqCHj9G5QXWr9qtomFhmlAtCj1fN4nQ1Kh3+DaqLbjcliop1sCGArYaKIcHaZUlPszyGKyvmrY07gx5hy1V941Zsxg0lPSehrsISjqNhCd8pZE1LUcuIBqhFr7qTvdHypcfDxJe+EAYguPEXHw3FK/71QCC3RkiRJpaYY935KLzT3U+WNFIWBv10Bn+N74o5B+4ZDTGUnF2AYT/rX9DDl+k/t5x+GEoYul4TMowF5lvrriI4NgMb3gtQtbZZixCmsjUwFlsD9feMYcjL6rMRmHfwPr57thUG850tAMgtLJYJZYB2UGbtvyta7Q0RQns+lAhTgRsxGZi4+Tra1XHH9muxMqGy+UqM6r1gLV8ZiCx7jQ1quTsabffG2iuISs3FpksPZZ2OsrhcO862LlEpNj0PX2ynwteaWP8dQerD0d3iY4YB4FRoCkYuP49nGit7dswJZSWCHj5WjRMVMPwNBN59AuOBGyZmShHErCUohY0YMnHzdfRq6oWhbfSGmNj0PCMvkJRRKy9g43sBFnfulXIarA0bKytqYVZlRSkOG4AY9y4g7UhLn9XHCqFZWQVanA9LFcOVpM9DeUzOtf9WfJUTy6Sqzgjk7+/PXbumnt3KeDJI3TK5hcVYeSoc/xnYVAwjUNrOkON3kzB+4zXMGNlKZjXU6Tg8TM9DQy9nsYxqdhq0q+sOe1sbsWEb1cEXDTydMWlAUyOxLRx3zdv+uBadjosRadj6QTc42WvAcXIhu+DwfaziY83C5w6DDSGy9WvORipOsbp5fFcxJGPdO/7w96uBd36/Klo7W9V2w13J2KA3vhskNuhr3/bHkuMPcCdePnboL290QovabqIFz5A/x3XFm+usG981ev4IIyuHp7O9zO313bOtFN2d/xb6NPNGh3oeWGqBa/lp5sGcYWg5/XClDiFoSJs6bgh5VPXHyGUwGFWb0QH18MOL7Z74cQkhQRzH+SutY5ZlhsUsPxmOX89EwMfdEa90rofw5By0lcQ0AsD1mMcoKtahgacTMvO1qO1WTbR+XoxIE8Vyak4hZu67i33B8VjwcjsxKSFfW2IU+L+XTwhp4eOKbo08UcPZ2MoalZqD387SxBoh+1hg3Tv+6NbIUxTKAMRYwU3jApCQWYDHuUUyN6gUqRxZcSocfZp5i0IZgEwoA3LL14Ij9/WuZwkfmUkgslYoAxAz76UYJmf8m4UyQK0jaqEG/ybeXHulSgllAEwoMxiMcsFwiMSqABPL/2cUaEuw8EgoPh/UDMlZBdgWGIspw1qICTWmEBLtsguKMX5jIC6E06D9+S+2FbcRMqelzB7VGgBw9G4S1l+Iwrs9GmLIkrOixdNSl6zg8rnx3SBUNxDM8w6qu9vGbVD3UKw+G2nWNSsNobgRk2GVu0xJKFcUPX80drdZEnPHePq4Gq2c8MdgMBhPO5qKmn2nDLCh455CjtxJNDto/9pzkYqWxr+uxGDd+Si0+f4I+i8+g9/ORiLucT5KdBw2XoqWDY9mOL6xELGz8EioKJQB/YgZanwnicmcse8uCrQlZjNiTXElKg0RKTni2JdlwZIYRqWkCwaDwWAwGOWPpRMsPUmYZfkpIzo1Fx9uCsKgVrWw5m3F0BokZxVgzoF72BoYi78ndMeIZefRtVENDG3to5hBzXHAb2cjsOBwKBYffYACbQkm9GksJryVN9Kxg0vDhD9LNwYqg8FgMBiMqo1h8mFVgInlpwxhOlRTk10Iw8LkFBTjXFgqHmXkY9f1R9h1/RFa+BiPb8uBEzNYhexkwwSphUfuy8bXZTAYDAaDwShvqmDIMgvDeFqRDmIiTB1qiNINpzSsjyUDogiznTEYDAaDwWBUFKk5pQ/TrCiYWK6CvLjqgjhjnCGGAvhWHE02+/VMhBhiIcyWYylf76za00wyGAwGg8FgVBZMLFdBrsdkIDNfi3NhKUbT0ArEZ+QjKjUXz624IC57kJyN7YGx+HwbHYA/IbPAopmDrkaxzHoGg8FgMBgMJZhYrkR0Og5rz0Uiv6hEcf1b665in2ROeUA/9XN2YbHRhBbhyTnMSsxgMBgMBuOppQqOHMfEcmWy/3YC5hy4h0VHaXJdVGqu0QxsCfyEHjFpeZi4+brJIeM+2WzZ/PMMBoPBYDAYVZGqOM4yGw2jEskvouMYZxdoUaLjsOVqjNE2HIAZ/9wRR6I4YGBpZjAYDAaDwfi3wGbwYwAATtxLQsvabrJlS48/wGp+umYpSqNcMBgMBoPBYPwbqYJamYnlJ8mBWwno2qgGxm24Bi8Xe0we3BwAsP1aXCXXjMFgMBgMBqPyKdBWzIRoZYGJ5SfE49wiTNysn3kuNacIV9goFAwGg8FgMBhVGpbg94TQKkwdvfvGo0qoCYPBYDAYDAbDUsoklgkhswkhtwghNwkhRwkhvirbvUMICeP/3hpDgoIAACAASURBVCnLMZ9aLJglj8FgMBgMBoNRtSirZXkhx3HtOI7rAGA/gOmGGxBCagD4HkBXAAEAvieEVC/jcRkMBoPBYDAYjAqnTDHLHMdlSb46Q9l+OgTAMY7j0gGAEHIMwFAAW8py7Ipi0qRJuHnzZpnKeJiWB3cnO1Sz00BjQ2BrQ1BUokPiw8flVEsGg8FgMBiMfx8OtRoDGFHZ1ZBR5gQ/QshcAG8DyATQT2GTOgBiJd/j+GVKZX0A4AMAqF+/flmrVilk5muRkJmPhMx82fImNV0qqUYMBoPBYDAYTwfu1are2BNma0QIOQ7AR2HVVI7j9nIcNxXAVELINwA+AQ25KBUcx60GsBoA/P39KyXK9+effy71vpsuReO7vXcUL1YOlC8ig8FgMBgMBoPSrFbVMy6aFcscxw20sKy/AByEsVh+BKCv5HtdAKctLPOpgk0gwmAwGAwGg1F6quIMfmUdDaOp5OsoAEpq8QiAwYSQ6nxi32B+2b+G7AItfjr2ALlFJZVdFQaDwWAwGIynlqoolssaGDKfENIcgA7AQwATAIAQ4g9gAsdx4zmOSyeEzAYQyO8zS0j2e9q5EJ4KZwdbbLr0EDuvs1n4GAwGg8FgMMqCo13VmwKkrKNhvKSy/BqA8ZLvvwP4vSzHqmqEJWXjjbVXKrsaDAaDwWCUmQUvtcPXO2+VuZzqTnbQlnDIKSwuh1pRhrf1wcHbieVWHqNqcu7rfui14BR+f7dLZVfFiKon358SMvO1lV0FBoPBYJQjdTyqVfgxfN0dK/wYpvBysVdc/mqXeuVS/piu9fFxv8YAgFEd9POUDWldy6pyPhugj/Jc9UbncqmbKRa/0l5x+Xs9GpaqvB9famv1Po28nUt1LDUaepVvedZQmvOvV8MJ0fNHwMNJ+R6tTJhYZjAYlcZn/ZtUdhVKTa+mXpVdhUrFXlO25uPaNEtzx405/kVv/PCi9Y2xOVwdqbP16Oe9Mbyt+fGL9k7sYVX5Hk522PtJT7PbTR3e0qpyLeWD3o3Qsb7xnGA7P+pudt/n2itO0Cuyd2IPfDu8Bf4zoBk+6tMY178bhKWvdxTXD29b26q6fjGoGe7MHIITX/YBAHw1pLnRNva2Noj6YbhF5Zm7X+1t9evXvO2PZ9vR+k4b0RL1aug7USPa1ZZdiwaeTvhzXFf89pZe0Pdu5o3XutQX76FN4wLw1ZDm+Gt8V9k2AgENa2D/pz2hKedY3SWvdcDtGYOx4b0AhM4ZWupyXreiI/X5wGaInj8Cr3Wxbvjfyu5EmoOJ5VJwLiwFV6L+FWHXDEal0srXvVT7fT6wWaWPXb5pXFfZ9471Pcq1/De71cf5/yoNXU85+FkvAKYbmTFd9Q2WKStTYwOL1m9vdUYNZ9PWnWNf9JYJDGs4/99+8HJxsGhbQ2tvCx9XNKnpitEB9RHgV8No+20fdDNatu4df6Nl68d2wddD9QLsswFN8eubnTG+Z0M0remCJa91wIkv+2Bgy5qy/aLnj4DGhoqa1r5u+P1dfyx+pT3e7CYXByPb+8LblZ7jua/74dzX/XB6cl94uzrgwZxh4nYnv+yD39/1x8b3AsRl43s1xLVpA+HioI+U/KW/DaLnDYVUT73VrYH4uXktV6NzrONRDfs+6Yn2delz9u3wljCUY9Wd7NC5Ab2Opyf3hYeTnVE5ALBsdEfF5Z0bUPHt5+WMD3o3hr2tDQgh4v3zqn9dAEC/FjURPX8E7swcgpvTB4n7/zmuKy5901+xbGcHWzT2ps/5+F4N0cjbGdNGtBSFH8dxIISgZW03cZ+2dYzfKe3ruiuKbR835WenoZczfnq1AwKnDoSNDYGjrUZc52Brg4WvtMPPr3XAhSn9sf/TnujZ1At9JOJXYN4LbTFtREv0bOKFif2aiL+ng62N7J58oWMdtKnjLlrkAcBOY7lwXvu28f0NAB3qecDV0Q59mnnDwVaDZaM74qO+jRW3ffcZPwDyjtovb3QCAEzsZ96o0am+B6Lnj8B/Buo9Ajs/egZb3u+G4OmDTXZWhrSuhRNf9jV7jMqEieVS8Na6q1h4JLSyq8FgWMT+T3tixwTzlqPScG+WsrUiyEKroZ2G4J9PzFvnQmYOES0xK8Z0lL2Qpfz4UltEzBuOEQZWrKGtTVsJq6sIBDVsDNqx1W91hq+7eRf+JxY0OgIzn2uDutWdVNfX5kWyv0QwXv5mgCgWfnyprUyQejjZIXq+fFas0QFU4M14rrVs+ZDWPrj+nV7Q/PNJD8x7oS1u8Ms8nOzQwNMZq9+y3j0+oU9j1fMS6iOlA98JeakTFV2cZAT+X97sZLR910aeRssGtJSHAEwe3Ax9m9dEZ97KGuBXA18MagY/L2dMe7YVCCFwsNWgsbcLqtkbp/a0koiz/i1q4aXOdfH9yNbYKhHqDT2dxPvETmODejWcRPeytJPRyNsF/VvUklkaCSHwcnHASl6sLO8DDLv4OnBmgbjNzemDMPv5Nrj0TX/smdhDsbPm7KBB27ru2PJBN1ycQgVpGwUxKeDn5YwL/+0PP0/6+8x7QW69b6rQQX2/VyNEzBsO92rKz9Cc59vi3Nf94OZox9fJVuZm79nUC7Ulz84Xg5ph2ghjy7qDrQYnv+yL8b0agfCSX7gXhOs+5/k22COx9gt12jiuK97v3QinJ/eVlWlDgD/GdsGf47rKxKnGhsDe1kbs7Kx7pwv+M6ApPunXBN8/2xoOtho837EO6nhUgyt/XtJOjPDRw8me1pdf2a6uO/4zoCnOft0PdhLx+Epnem/Xr6HvtDrwAt3FwRYNPPXPS+9m3vjljU6yjtLAVrXQwod2lgw7bVKea++L/w5tgavfDhCXvdixDha/0h51q9PfoBb/XnnNvx6Gta2N6PkjUK+GE5ardJZC5wzFgc96Yr2ksyfQuUF1dG/sCXcnO7zfWz2c5be3/FHNXqO6virAxLKVZOaxWGWGdShZHARGB5RPnODlbwaormtTxx1dJIJKGgv4xaBmZoX0iS/74JnGxgIEAKrZaxQFoKeLg6rVRqBXUy/0bV4T7epSi8TgVuoxjS4Ottj4XgCi54/As+2oC5TjW0qpYPN2dYDGhmDlG51kwnDZ6I64OnWAkViMnj8C0fNHoGdT+W/Utzn9PlAiso593lv8HPmDvJzBrX3gxs86JVhoAODIpN6y7SYPaY7N4+UWaYC6mIUQAID+noL1csv7xpZSAKjubI/Dk3phwcvtxGU+7o7YMaE7Tk3ui9e61KeN+8hWqO5kh68Gyy1rQdMGYt4LbRA9fwR6NfU2GS/Zrq4HxnStDw8nO7z7jB/+5K3qfZvXxEgD9/xRyXXqUM8DzpJG8OXOdfGJQujNPj404YWO+sldz37VD/980gPLX++In1/rgP/yVuDBkthXT74z4GyioRU6Y1I39PhejQAA1sx81cLHFSvHUPG68b0AbP2gG2wlgsdOYyN2VHzcHPHZgKaiqNNxlh2pQz254O3TzBunJ/fFSEFnJASLAlEQn7Xdq6FDPQ98P7K1qvXXyd4WvryFfmK/Jtj/qT4UhBi4/p0dbLHzo2fw7jN+eMW/Lo593htLX+8g7muIxoaI96oS9ra0o2BIIy9nzBrV2mh5/xY1xd9HDeFwQtXdq9GO4JvdGkBjQ3Bt2kAETx+MG98NwoM5w0TR7OfljC3vd5N1nvs1r4meTb0wqJV6h7q+pxM+H9QMk4c0h7tKx5pIbPaCNdxoG0Lw+aBmqGXwbhTuo84NqovXpIazPVaM6YjTX/UVhbDAsLa1Mfv5Nrg9YzCCvx8MQO85Gt+zkap3QKCm5Pg/vdYBL3Wui7E9GmLt2/4Y2a42QmYOwTyDMCfpvSl9VznYatDa1128H9UgBj6NLn7VcXpyXxz4zHxYUlWg6s0pWMVIzy1CNTsNzoWl4ODtBOy5GV/ZVfq/ZedH3fHSL5es2qd5LVf0ae6N0QH10W/R6XKry/YPu+NxXhE+3BSkus1f47uia8MasNXYwG/KAQDUEhscl4HXV18GQK2HbtXs8NuZSADAgpfboZGXM17+Vfk8m9Z0QVhyjmxZIy9n+Ehc8dHzR4jHU2JCn0ZYdiIMABWhXRRc2bOfb4Pv9oQAoC9+pVA6Ydl/BjbFilPhsLUhKNbpRcGRSb2RkV8EN0c7rDodjjXnogAA7et5IDg2A/8d2kLWyAp7LhvdEQF+NfAoIw8ZeVp0UoixlJ2/tzNuzRiMvy7HoG8zuct89qjWqFvdCfa2NqjpKm+gpKEHhm39H+92wY6gOHRuUB3H7yXB190RTRXc3AAksY2t0LSmK8b28MP6i9FGxxB4pokXrn47AAHzTojLXB1tcf3LTrBb3AQTiz6Dj7tejHeXdFSCvx+M9jOPit9b+OgtnAKOdhqx4bS3tcHYHg0x1iBJycXBVhSaAie/7GvyvgFoY29ohR4TUB/7gvXvxWaS67T1g27oPPsYAGDJa+3xQse6sn0beTujkZcz2tZ1FzsyOyZ0R9s67nC006A+qMh6nhfRN74bZGTB3DQuAI28XdBj/kmj+ko7Rw62GtyaMRhhSdlwtDMQ1yY83sKqCX0aYwT/W1d3tkc3BQu2s4Ot7JjCM6IklX3dHRGfWSBb9veE7igxENZ+Xs5AqnEFDZ/JavYaPNfeF7VcHZBTWIxxG64ZCRSAits2ddwxuFUtHL2bpHjqni4O4u/ctJareO+P6uALH3dH2NvaoEENJ6y/GI3+LWoqlGCekwZWXmuw1djgs/5NMFjFYyT1qNgbPNzdG3uivqcTDt9JlP0uGhuC+jWcEJOeZ+p2UEX6e0wZ1qIUJVB68R13GwLRMDDjuda4EpWOjDytrG6uEoG68JX2eLlzXfh5OePIpN54mJZn8jjHPu+N1Jwi8bvGhmAgb7CQhv8I1KvhhMOTemHoz+dQ09UBa9/2x6EQy0coefuZBlhxKlz8vmPCMxbvWxVgYtkMnWYfQ7NaLniQlGN+Y0a54mSvQZ5kopfODWogoGENXLUwXrxjfQ+sfstfdKXdnD4I2hIOXeYeL3PdAhrKBWYLH1ccntRbJjZ6NDFOAKtmrxFf5I28nWFva4P/DmkhiuVX/amlWSp43+rWAM4Otvj1TAQGtKxlJJaFuEvpfbr1g26iIDfEyd4WXw1pjoVHQo2Ex+iA+thyNcaosZA2unNfaIOpu0PEOD5p296jiSdsbaiVxN3JTrTC+PHi7fUu9fDF4Gb4OygOrX3lQq9tHXccu5sEP08n+Lg7yjoASkgbOjdHO8VYvLe6+6nuv0HiNpRaSgAqCl/1r4dHGflGx5Jye8ZgVOOFl7ODLd7rSUXp2a/6QaMhsNXY4M9xXfHmOvkwkzXdHFHb3REJvFga3rY27NJox+sd2yMAZiseT83VbQ13Zw0p10H/uzf2VO2gOdppsHxMR6w8FYFR7esYrT+pEKeo1HkTqK4QR92rqbrnxhA3R318LkBjjj2c7PD5wGaq+wjXvDRjv6pe5dxUHJvUA4U6eZm2GhszjbJ5C3XXRp7IyKMiyNQIF3NeaEPFshW3AiFE1kn4crBxHHBpcbbXILeoBBYa4fFFOR7bkNI8HsIzJbzXS4vghZBa/Gu7V8OSVztg7PpA1bq5ONiK4Ua13ByNrNeG0E6QdXUTDA5D2/igayNPxZAnU/tGzx+BkEeZJj0RVRUmli2ACeXKYf+nPdF/8RnZsm0fdMO9hGwMX3bOaPvwucPQZOohONrZ4NTkvvBxc5S9cIQ4uVszBqPdDGqdkzbyOyZ0R3puETLztfB2ccC+W/H46dUOMhHw1ZDmOGxBb9pU4yu+J/hGwcbMi2P2822QmFmAfcHxGBNQH0XnV+AeVx+XdNTyM7QNtXb980lPFJXoAEDR6iXlg96NUNPVQeb2llbK8IXcytcN58NTceCznvDzdMbU3SESq5l+n7/GK4cMCPUZ2d4XNV0d8XFfY3fuxH5NMKBlTbS2NOmPv36anESgprLVV4n1Y7sgu6BYFjc7ZVhL+HpUg7O9LVafjRSXCz+N0ICPDqgnS0p0VXE91pfEGPZUGTXjj7FdMPTnc3inewPagUqjyxspJOJtfC8A2QXq49Y62tmgQKtTXS/FSSEGV6BrwxpGycuuClYmJZrUdEF4svG7sn+LWujfwspWuRQseKkdErMKzG8owdXRDjenDza5zZRhLdDA0wmDTbjp1Vg+piOWnwxHLVeJFb8wG1jYGM4BH8B5+ELLCiIGN6IZPJzsjUKOjBCLqhrCpaG3M0IeZdEvJVqguBBweLJJvIteaY9FR0LFkBVr0NgQrHvHH23rli5pWUD4iQ3fwZxVQUMVQw1ne9ycPshsyIUpTMXMV2WYWGZUGLNGtcb0vXdKvX8jbxdc/XYAAqMfi9YdQgha+bohct5wNPr2IABg+eiOaODpBFuNDW7PGAwne1uTPVc3RzsETRsoizcEjC1a/Xj34tmv+qH3wlMAqKCTxu25V7OTjbl9ZFJv1HJzMDlOZEMvZ7zXo6FspAIlNo0LQHW+HB93R1zgE3Sm220CAPgVbJZt72inMXYvq2CnscEr/sZWp4/7NsG9hGyMaFsbbeu4ixntXw1pjiGta6G1r7vqZANKLl+Bxt4uZhtvjQ2xXCjzDLEJRMONY4A3dwJNLEsq7Nvc2G3s4mArCvh3JDHHYiIR31D98GI7o31LSwsfN2z/sLtRnKrSKBHS5K87M4fIkoMA4MBnvRAU/bjMddrwXgAyJHkZF6f0h5OFiTcHP+tlcWxuRWBoRS2voaicHWzNxtCq0blBDawfa5D4VJhN/9/bB1gqliXPVrdGNXA5suyjMXk42YOQsoUMlCe1XB0Rgiw42NkAm18DIk4AMzIr5FhCe/JcB3m8fUDDGthehmRow0TS0iDkYhh6fzS8x86hDFbrMqErAUqK4OFk0JEozAHsnUtnjn+KYGLZBJZYEBlyWvu64U48tQ683d0PS4+HIS23yMxeeqaNaIk5B+6J32u6OYpxglJsbAjmvdAWzX1cZG5VNUufIdJ4zZ9ebW/SklDf0wlr3vbHhfBUo3WbxgXguRUXxO/NfcxbOAkhmD6ylWzZxSn9jUSoNe5lJTrV98D1mAzx+5zn2yhmswPAr292QtzjfNSr4SRmk0sFv53GRrzOQj9EaHDsNTYYHVBPHK3gSdG5QXU0zuBj4BJuWSyWoc0HLiwFen4O2Fo2fJlJDRiyix7b0Th+WODwpF6ISM41Wm4YzmOSkmLgwWE4txhh1DA19nZRTSqyBkc7DXzc9eLY6LmIDQTirgLdJxrtWxbXc3lz7PPeFg9NV2EUZNFrZel9KZBwC/BpqyI+OKx9pwviHucZJeZZCx2j2Iz1+Qny06sdcOJ+Eo15jzhhfocy4OJgi5CZQ+BkoXHhSSKkfRj+uj2beOHjvo0xrmfpJkkpM9veBEIPyjswOcnAoqbAwBn0ffovpuq83aogE/5UT956Wlg2uiO2ftBNNhSPMO5lWYicNxwXpvTH7FGtsf1D2hOv5eYgZrULzH2hDQBl1zJA44rD5w6DLa/ApFY9c4zpWl8mlEvLi53qmg1bGNSqllFiEwAxPres+HpUkyVGWcLG9wLEa6/Etg+74/5s/QgAb3ZroBpjNrRNbYutZ072tpg1qjW2fUCPTQjBDy+2kw1hVuFcWY25/jl4pTMfRkKs+B0uLANO/wAErjW7qVk9knwP+HsssNdYPEpp4eOm2OmzivNLgG1v0Aarslg3EDjybeUd3xJCD6Fp1hV5fPNfrwArjIe2qlB2fwj8+RKQEStfbqrn9fAi8Fsv4PIq+XJJGIaLg61iYmeFELITuP13xZUfdQ6Y4Q4k34e7kx1efIIdbhcHW7MhcFaReBuIPm/VLrs/foZOzJRwi4aeAKhXoxpsCB2pSIrGhuDroS2MEnPLTG4qsKQtkHxffZu1A5XfO5n8vX1nT/nWqQrCxPK/mNnPt8Fz7X3RrZEn3pYkOo3qYJxo46mQONOslrqlysaGoI5HNbzV3U8c79XWxkZ8+QgTCfRu5g0vFwd8/1xrIyENUPe+YTjE00RNN/riMhzX15CZz7XGxyqDwZeW3s28TVom7TQ2NCwjL118EQMAspOAgjK4Nx9H4+1bb6O+Y77p7QqygJXdaENQ3hz6CvYbhsPTiXeOWWNl0/IW3uJCs5t6uTiga8MaWPJaB5Wy+IzzzFjl9eVJZgz9n5tS+jJyU4Fj06lLtQK5OnWA8YQq6VH0r6LZ8jrw10vyZWFHgVTJ2Phb3wA2vw7kZwD5ZQ9fUSSVjjgj3iOW8Pgh/Z8QbLDCINHhSfH3e8DOcerrc5Kp2C2toL6zi/5/yIvMMwuAZcZjZ1cJtPk05CD5Hj1nw9/o157Aeuss9R3rV8cXnW1pB+noNACAE4oQ+X0vDLNyxkNF8tKBolwg4iRwdY3x+oxY4OZm+m65tFyyPAbY/RE9T44D4gKVyxduR3Pv39QwWpZSZyI9Cjj3k0WnU5mwMAwVdLrKD6YvCxen9BdFLCCfDahHEy+c/LIPlhwPw77geDSp6YLjX/QxymZv7esOj2r2uBpN4+N83Bzx7YiW8HIxPbPX1akDxCQiJ3tb2bS2w9r44FBIIuY83waZ+Vp0tyKbtiri5eKA2zMGKw61I8Uai3m5s6Ah0PI54DUa64zFzQAHd+CbGP028TcBJ0/Aox59OQauBfx6ATUV4hkvLKMNxZ1dQMD76sd9eAFIuQecmguM2Va+52QIsaHnUJQL+PGTEqRFAO71AFuD+1XMoDHfSdPYEGwzYb0XRQxnWXKdSR5HKy/nOODIVGq5KisHJwN3dgP1ugEtLJsmuDQYDtMHAFjGdzgmhwNL2wPv7gPqWD+piUh+BrBxFDBgOtCEH2d8+9um90mLAKr7Aff30+8/8hM7CK7lLaOBzu8Cvh2Bv14GXt9Mnws76xO+xPvL0JJsSlhwJab3CS/7SD5myU4CdFrA3QIrbwpvjQxaD7R9uezHPjW37GVUFD+1pB2r/lTU4s4eoHZ79e0z4wA7J8DJjMctj8/sjbtG/y9tD+Qmm47X3vUhfR98fNF02QsaAq6+QDY/tKPh+/rnNvrP0lvuZ8kYyyZj0ES1rLw6LYI+B1F8on7ITirg6wUArnzC7KYXgMdRQMuRgFdTev+5VnxCsLU8vSa9CianSD3z/GnA16OaLKbNML6tkbcLlo/uiB9faovN78snSRjFJz30aeYtPgNr3/bH6a/64rn2vnimsTy7v7a7I/o198ay0bQxrOnqaFY8Vneyx8R+TcR6fcwnzWkIwfYPu+PEl32sPOPKw9XRrszxgyLRF4CsBOV1gstSjcQQuo0B+Wl2uPf9NWiTkvQLCw1exKv76F+cd/dSUbWqKxWgaliazGVuuzt7gKizlpVlVLYgUgk9h/W8AMxNA5Z3Ag5+qb6P8JsVZgP7P6dWI2sRykgINi3UspPon0DoISDprnybPR8p75v/GLi8Eoi/YX39UkJpnLGA4GHQmXm/HZhMG7aKIOoMte6fWQAErrP8PspKkHsD9n8OJNwE/nxRv+zuXtNlLO9EQ3DUCD0IbH4VuLGJ/qZrBwFzfeh1TLgFnFmo+IwZkRii/2zYkRLON1vhORfCeSztfOWlA9d+N73NyTlG743skyehKyqidcnlxdq6ITRUZXEzYElreeesKM+0N0r6G5ZogRze+xG4DoiRDGEZd40KPZ3KNVEr++5eus/8BjR2VlhuuF9httxrkpNMO1XS8xDO1xQ5KUCxQa6N6IHgn/nzP1FBrMaS1jSe1ywGbUduMv1/+29gZVdjz0dxEXBrK5BsInleWwBc+Y1+zrZiboicFCDbMFfLzG8DUEGck6K/Hqd+AB4coc/bMolXTlsAbH8LWNycerlubgaK+PfuphdpO7C4mfnnuBJgYvlfgKujfDpMNc5+1Q9nv5K7Rl/rUt/ICiRMe1nd2V5MCPP1qKY60oKtxgZ/jA2wKH5YSFprXFMew/zFoGaInj8CNjYEAQ1rmE5WKi40Fg4lWur2f9pZP5y68wD60pI2NGFHlfcR+LUHsOFZo8WPw+i1zv1lkrwBUAtDyJMkMq5W6LRcW0f/H/pK7lYrKbYsZi8xBFj/rN6SuuMdYMNI0/s8fkgb/Hv75MvVrMRCZ8CkCOcbqR/qUsFx5Rd6nJRQ2jBL76fcNODyL8aNs/S74Qv+7l7g92H08+Jm9E/YZ8vrwC+lzLpXEhYXl8umQhZZGUDjjIXrQMxYwsOPA0EbgMA11AUP0GuhNTEk26PrQPBW6+v/4DBw4AvLXfg/tdDXCZDfp9bw0IKJjYQOqyA0VgZQV/mpOfQZu/aH+r5xQfRZFMI+Uu6pb1tcCCzvDIQbJLQVZFJ3PwBEnlb3Ouz+kHYalLwO9w8A2nzoTi3E4wgncLxAzQsKQtzHE5G8aBG1CC9sRJ+t2MvyUJWj3+k/r+gCzFcavYe/nx6e1/+uf48FFjWhZR74Avh9iH7zv16mQi/6rHz/K78piDSem5tpRzRwDVCQoX8HrOkPzPSgx935Pj3eD3Wpt0EIgVnUVC9Ytfn0HBbyuRkHv6JiVIlFTYBd46mnKjdV3iGRivGd4433TZb83rpiYP8X8vW7PqCeomUd5cI9N5keSyx7HLXc/9yentsMd/puWiNpw6W/kcDKbsDcWsChr5XrNsNdOTQuMZie92KD8auV3jc5KXxHl3+P6LR03yV8Xs+Z+bTTaUiwZASn7W9TA4EQVpYZQ0dBASzrkD5hmFhW4bEVIziUF4YTI0hRstQK0wMHTh0o3s/zX2yLhS8rD29V39NJNv6rITs/6o4/xnbBpIHNsPqtzujTzBvTR7bCpnEBaOVbPgklowPqIWjawLIlqBz4Eljdl8ZVAdRasPUNYH4Zp47mOBrPmRZh/b65acD2d4ythdmJVBjuGKu8380tQPA2/fEBvQhY3Jw2NCVa4MQs4N4/ymWUTjMinAAAIABJREFUaI2TiJSIPAX886n++5ya9MVtFL8qt3ToiopQGBkJRaQxemcX0O8PL9HGX8lSO8OdConoc8Aa9Sm6jbizm/43FGVXfuGrrGLZl77o429QK5OawM7PAJa2o8JoaXt6PwmN2Z4JwOEptHHe8BxtdOKuAZueNz6eUP72t4GYi8brz1o6XJgVHJ1m2oW9YaTeJQrQDooSf74E7PtM/z3zEXD4v7Txld4nF1foP6/pR0Ubx/HCOt+0xXjXeOPvl1Ypb2uIED6hRJKBpW3Xh9QqZ/g851sw7FqgQnynlP2T9B2Iolzgtz56L0zGQ/m2UoGfmwbkSERhUgiQFk6FjfTeDj8GrOoGzPam4u/gZP26kJ30GgN6cSXt+HIcvde3jgEOTkbqHVckBnog68ABIPIMSn6h3hdt3CPayVIj8pT+cxZvMUyLoEJPaTDge/8od2gB2onOSdZbSTeOAk7O1W+bFmYs0gSE93yafvY3xN8E4q/Tz4FrgdvbJcc6B6zw138v4dvyuT5U1AlcXU3F6KMg4Ec//bMudNzv7qXhCAsb0w6JwOl5+s8xl6iXSMqqblS8CwjGBYFb24BLK4D0SCrcj07Vn+dChbwWqRdwZQC9ZwQuLqP/fx9Gr/3S9qY7Z+cW0/97JxobElTDvBSe47/H0o5QGt8pMYqxN+CAgofP8HkF9PH9xWbyYSoBFrOswk/HHjzxY574sg/eWHPFaIa2dnXdsWJ0J4SnZOO99TSu6VX/uljwsj5e6seX2mHBkft4qXNdozFYLUVqGRamEXWw1ZR5CDMphJCyZfOWaPXJBgVZVETteNe6MooLgX2TaOyZuyTZcSY/3m3oYeCTq/Lt59QCXvgVaP+6cpmCteLuHmByGODCj+W7ogtQyFso63cDmg2h5YUfp8Nv7ZlA17V/TX98gGbFi2U3VnaBavPpCAlnfjRet3cidYn1/Ua+3NA6fWsb/ZNy8y/Z18Qpk5F58BiaXroI2+oKU09vehHoOkFvUdn+FrUW2PDD+IUdoVYUYXxZgbxUYIkkZi49kootrybUknNiNvBfPiHs+Pf0//39yi46o/hjvhHPeEgbar+etINVxx+6mh2RessVXiVTYSN1cV6SCEAhmS4vFXD21CdeATSMYJXy5CuY6QH0/Rbwf095/YMjclGbk0zHKDUUixxHG/L7+2nMrKVo89Xja5eXInFqiWSIQ6lYPjqV3r9SsXRiJr0fAz4Erv5G73tLh5M68g3Q/WMg7DhNzpsYCHg3A9YNBmKvGMdvhh2TN/Z7JgI3/5Rvc2srf28bNPbJBh1agHa2a7Y0Xm4KwaoWdZaGgxz7jj5vfyt0jG//TWN6hfeEwJr++s+7PzTer0TBaPP3e0D70UDwFv2y7EQqdhzdacf8ER//euNPlBTSEAzd1c1A0EEAvCeR44B0eUci+ZYrbGw5eLVSCUnaMppany+toMOF1e2iX2cqDEkp8e2sgifEkKAN1EoJyMMp1kqG47u1HYqoWeMNEX6Dw1OAwXPk91WeBSEbW16nsclSbhvUaWFToMs4oIbCiEOxV4yXGaArBkoKbWDnrOARSr6n75SbO+fbO+j/xFvmvXkChp3eswtphwRQtmxLk8lNUZBhtIjTASAAsWZ0oycEE8sq7L1pRZxPOfDX+K6o6eqI1r5uCEvOQUMvZ0Sl0qz9EW1rG1mFexoI2O6NPbH74x5PtM7lTvJ9Khw8TFiIZxvMhhZ2zLpjRJwEjs+kjVthFvD6X8bb5D+mIQUa/vHITQXAAcdnULF84EvArQ7Q6wsqAE8aWPQWNQWmJlFrUKHElX/oa7lrrKtKjCoA/DFM/1ktVvD0fODCz8bLHwUBN3jhEHkaIBIRbs6qphATnXv6EABb6O4cAXoqdBYiTsjHRRXcalIrTrqKZVo6isSyjnwdMvWWnOsbAWeDzppSoyy1ihQXipnlAGhD3ee/9POja0g7FY+0u67Q2OvgqVmkXC+By78AzYfL3dPmOD1Pbn2SWqUMs8oXNQW6TaQxyQIxl+QdJ3NIn4G5PsCUGNqINXjG9H6/D6UdwKUmkpQA5CbaI+W2GxrovOV9kogT8tCP80vo/6t8rOTxGUCjvoCLj/w5UOPmFn3nMeYSoLHTCwmpa3tpB5oQJNvXQCiLWBgPfX+/aau1EmFHqRgXhtTiOPlzK2XnOPreUUNqNVUhJ94BzrUKQTSQC2WADilojqjTQBMARP2apN2lw1eqimXpc3B8BuBoxX1aGqReDqkAlb5b1LxK0vva8NpvGW28/e3txiLXUsyNeJKbrBorz5UAcRerw7ttNhw9lHMJ4i7UQG6CI1q+rqBLrL1vrcVwyLiTc/SfldoTwzbaCu5v94VLnXzU61z1JjhhYrmK0KMJvcE+6d8U9xOzse2D7lh5Olw29S4ArBzTCbuux2FI66qXLWo1UedoD1eY4GAVHz82fBFQuwNQr4v6vgB9SSYbuJxKtPRhHbYA6Kpgqdn0gv5z/A3lzNvcZOqmfuFXwMEVCOFjKrMT5GIyN4VaNIVQAClzLfh9ypoUqJakJbVWlYGCDFto7PWWDLL3Y6Clmd+kPNBKXHDSsBFT3Nik/zzHeIY+qfWdy8sG4ApOZ8H1D/qD/pUFabzjOQVxLhXKlrB/Eo337fAG0Oo5GgcqRYgtvb7BdDkxl8wKZQCIv1IdxfkaFOcbWLay4s1bxVb3NVu+iCCUAblIAuSxoYZCubIwDGWJNhNnKXgrSkFeij1iz3qiRvMc1OpYytwMQ40ceggoazOiYB20Fo4DMqOqwa1eAWzsaCUfXayO4gIbNOhvgWXXAssszhsMTVaZY5UbkP/YDjmPqqGkQAO/Qcpx+LkJJmajlIrXikAtZKuCyHlUzbpx858QVa9G/wcIscYC0ulum9R0weFJveHuZCcm7dWtrrcoj2hXG+ve7QIH2yow81BJMRWPl6xs7AU2PKuf4ECayHZwsjwpCaDWVYXxUHUPb8hzlZbymbeHvqZu48cPgRSVkJqsR9Q1reQ2ur+fJovoSoAYlZfx5VVy1721CGOMAsZxb5ZQlmObQFcCJN1wQ9Thmgj/xwfgJKJSKeSjFBRmaaArVhGrc33K5RhqcHyIRlWbnZXjgISr7shPt2AWygeHabiLqdFRyonifOFdY3DBLO3IlAfSOM1yICfRATkJFTPDH6cDkoNdUVJYfjdYSSFtqotySvHeF3I6y6025Utesj0SrlZH4nWax1KUo0FWTDXkJVfyDIwWUJSjQUkRvcDZ8Q6Iu6AQpmYhqu9DK9Dm2ZRqCPW8ZHujaIvQnT64t9XX4sFqpGTHOSIrtgzTzVe1lzOYWK4UnOzlLzy1+2JMQH1s/aAbhretWPEgEhcE3DAIS1j/LLDxeeXti/kEF6WebXai5RNf7HhXnjEtsGEkFQNx16i17Ec/ALQxKsrRAByH0J21EXNKEtMpJKIAwKwafMJWF5qUZSAsigsJ7m10Q+5EX/VRHGbVAEIPKK8rA8UFNkib+6n+RbRFJRa6HEm64Y6MyGooyjZucIuyNciMprGumVFOSA9VGo2EM45vLgUcB0QerIW4c6VvWMpWAf6/CXd0ZVBcYIOMSGfEnn2CMyFaQWkaTTWkwiAvxb50ItAECdfccW+rr+r62NOeiD1TMWO8Z8c7Iu2eKxKvu4PTAal3XUQnUGGmLdJD9SMB5aXYIy3UWaWk0qPNt4E2r+Kbd22uBg/21EJhlgap91wsEmocB6TecRHrx5XQe6G4gN4DEfvlxqT8NDvc2+qLwsyq5wiP2F8LUUdomFjcWU9kx1ZD/BUPRBxQ8G6pwRsjCjPtxA5cUbYGKSEuYsfLUsL/8UHceeX3x6NLHki9a/xeT77liocnvZB+X34f6rSlv3/iztfAowvyenA6oERrqQhmYvn/ltnPt8GiV6jL08aGYNnojlg2msZoqt0WhBB0a+RZfmP4/tRanqVryNr+wN6P5cuiz9Gs6M2v0/hReQXpf8NWdO8nNLN5aQcYUVxIs8elGerCSAeq9ZKPmpAc7IaI/bWg/akXACAvxQILhDAouoSCdDpZRdo9F6tnXrIWbZ4NUu+6iJcq/pIHkm+4ozBDvQHgSgBtrulHVFesn8fAHDqtDRKuVhdf7lKijnoj/jIVr6oWt3K4DTkOyIignpLcpDJYHqoo+Wl2eLCnlmhVLMrRKHZOKoL0MCfkpVpglS4Dj1WOoStRjgriOBhZyjMiqyH079pi5+zhCS8jgVRasmIcUZBhi4xwYwHKccDjcCdo8yu42eM9Xdlxjri/3Rcpt9yQyscCRx72RtINfaf94QkvJN8oP++ANleDohwNwvf6UK+QhKQgD9EKao5HFz2QFeOI/DQ75Kep31MZkU4oKdAg8mAtpAS7If0+FWOJ191knZWMyGrUSlkCFGXZIuW2m7GoU+mMRR+j7ysloVfRFGZpwHHUsJIT76DYYdTmyt/hmVFOKMo2L+y1uRpkP5K/a/NSaJsUc8YTqSFuuL/dF2n3zItlrkTfAVUL2ch66ISUW/JRqLLjHcQ4deEeNUVCoOlOqBI5iQ54HOaEmFOeeLCzNu5t9TV6VxRm2v6PvfMOj6Ja//j3zOym9x5SCEgIkIQaegvSu9QAoqiAXhFsiIJef9cLtosN9VrQq16aAqJIEZTepFwCCKFKCwECpJKebLI7vz8mM7uzO7vZJJsivp/nyZOdmTNnzvTvvOc976s8tmoxyBuYxvepdq8iCHCvtCh7u2oxql0T5JeWg+cY5vS3J3C5A8i/IQ5gGFdFWCRAjMf7h4lrwB9bxb/2D4oWYzc/yOqpokTM6tb1CUDjbPQfNXf+v3PWGFt2nFk4HTMEAYCg7rpUdFt8wEhdk7WmHj5ibxzwQ2mOEzzDS+DspYe+8qvd1G9WX87Aa41PjPT/+SD/mhtixt8Cp1F/k1xYJz64WiWlW/RQ6MsYBMFy5wwVlsfN1IpQeFMZTcHYDW+bK1sD4eRZgfBe1tMHl+ZocTtZOSgo/7oLeCcD3IOrDtdYmqtBWZ4W6Yd9ofWoQIsRGarlDOUMF34IVffxNDmUxRlOcAsybre8iIdBDzh71SwddNZZD+hLeRRnOiPvmisKrovHssXIO8i54A6fFsVw9lL3NZfPlCAKT4OegXEAxwuq94FgAEqynJBx0guR92fhzjHxuKoOApL2r5iDvoyDxk2P/FQ3+LYsUlw3FaUcMk55IqRTHjiz024qaMN7Z4MxwKNJGQQBuPC9eB1GP3AbGhejX9T5NeL8iD7Z8GhSBl0Bj1v/q/woS3eGd5RjQ0TdPGjdKl+S5SRee8nGeXdOeCHnggdCu+TizglvRA3MRMZJL4R1vwtOI0BXwON2sjfCe+WC0wrQFfJgvACtq7iPmSmeyLnojpZjbuP2MW8Iega3QDGMm6A3nrTss57waV4sWxHLizhoXJWRDfQ6hrI8LdwClfeBoYJZhMUuL+LBOxvk50LuRTe4+JXLwtIU0ydAzh/ucPG1dDvTFfBIP2K8L/PT3JCfZnT/ix5zG8UZTjDoOLgGlsn3R4nZh5Mk2HL/UArbjJOiSNObPGfk3gWTTN4GG5ZHu8YYmFFw0xkeoWXy/ZNz0Q1O7np4NLGd6l78yNXg+l5/NOmai/Qj4jUb2iUXPs1LIAi19xS4sjUQhgoOnuGW94BkbbeYb7ZdfZn4jEjdGYCyu8ZzUV7E4fYxH4Qk3IXWzXqCm4oi401ujyX57mX1XhDJIODkqXxulhdxuL7Hsgfn8uZgRD8gJmkqznDCtV0BCGxr8pxuRD7lEiSW6wkBwODYEPxzVCwmJojRHrxctLj8Zt2lnK0Vu99Qj7Tw68vAkc+B6duBEJN4zttfFcMVTTSzPu94TQwxZCqUAXF0uA3uHPNG7iV3+cWfuj0AXpEl8Ispgl5XeVPXVuTWQy+8XsfAOwkmDyJ1B8KCm864sd8fTftnyS/LwkoLgUEPlN7VgncyWBVx1/f5wb9VoUJw/rE+FADg3azIcTsE0VLAaw3QuuuRdcYDwR3ywTixG7EsTwvAulhWe5lL3XW2RF72eXdk/K60wJUXalB0xwmZKZ4I75WrEGkVlR9SORc84B1VDBdfo0CVDn1miicEPYfwXjnwDBddii5tEgVheK8cuPrrwDsbwDjxHJRkO8HdRFjfPuaFotsuiEzMqhQukMWQoZzJQtm03tzLbghJyMOtI75oOiATbgGicEnd4W+SL4Th2s4AlOYa03S3npQOQRCtla5+5dC663H++1B5e7p85aO8vISDQcfB2VspzCVro0eTUhSmu8A1QAdX/3KU3tVAV6ARfQ2vucE9UAcXf53SX92EG/vFF2D0A7dx8SejBfPiTyHyeTS1FOkKNQDKcPeqSYgtlarTj/ig4KYLYsaqJ6i4e9kNt476wL9NAYLaiqEIr/wSCDABzQerD466vt8XxRnOqmJAcjeSBHz6YV+U5jihML0EXpGlyDjlhaI7Lri0OQhad73cGxU1MBOcVkDWGc/K/Q6GvkwUDHlX1WPZZ583CshLm5RW37yrrrIgAwAXfx0CWhfi7hU3FKYrLYX5aS7yR0GrienIPu9hYTE03fdCE0tj1mkvhHY13p/lRTwEA5B52hMlWdZ76C6uN7aXcQKaD8tASZaTRe9Q9jlPhRgXBPGjSDo2AGS/Xl2+Vh7cB4hjCVJ3KiMpmFrCGRNkq2ariekouCneCxo3PTJOeqG8iEdQu3w4eYjPSPlaaV2AoHYFEAxQfFDe+M0XBdddFddrabYWnFbAla1B4J3FekzPS8FNF+RddUNxpjMiE6tOiiOY9DK4BugUwlUyWhTcMD4nss96QpevsWqgOL+mieI5+cf6UPBOeuh1yvLS9XVpYwj8WhXCI1Q9qVDmGaU1OfO0Bww6Dlp35XumJEcLJ3fjs+TOCS/ZCKEvY7j8s/h8825WjJCORvdL8+tcoqJUtNif/z4UqPwIstWD0RggsVxPMIjuF9N6RDV0U8QoELyzmOGpRX8gTCX+amVIr5yLbsg+64kWI++IX+dHPheXfzUQmGGWdUot/u2BD0T3DXviVZqQa9aNWpLthJJsJ/jFFFl9kFzb5Y/iDGcL0aUrFF8Izl566HUM+jJO+QVsp+jOveQGrbseHqHWrRK6Ah5Onnoxi+wtZ1zf54+wnqYWdjOVXLltaTDLnd+94N+qEJ7hpSbNYri2QxSZrSelozBdrLf5UKNVteiWi/XQQipIXdIZJ7wRM97Y5VVhy1pf2SDJUuAZUYKC665wC9LJYhMQuy55ZwM0zsZ9Lc7SWgg3W0jdclIoJXOhLJG2W3y53r3sBtdAHfSlHCpKeWScMr4EdAUa8YOl0mIsWb0ky1/BTRd4hpei6I5RnEpdxLyTAS3H3sad4964e9kdzYdmyPuRe1Gs59KmEPDOerQcY0xnbfqCNUXQc8g6LbZNOqfBHfIUQsVQzimEMgCkH/ZBfpqrbF1rPSldIWRNexCk6wMAmnQThZGhgonuRnIZUeSkbg9EZGIW0vaIx9GrabHN9ptTnOGkOt9QwXBhXag8rS/joC9ncpevxM2Dyl4GNaGZ84c79DoGn/uKceuoWD77rKcsliWL2u1jloIxba+f7UgCVshPc4VXZKn8waMv4xWCz/yjz3SZNdRcQyTMj3dptpOq76m+lJePASCG2rKFeS8RANyq3FZFKSd/xKlZN60hGJhNtxlT635JppP8YQUAGb97QZdvFEW3k71lC3ZJppOF9fiPH43XkKml29p+F1x3RVjPHBh0nHycCtNdEBBXoOiJLMvXyOe2vIgHICDrnCfuXnKHX4wYNk/tnJoeT+meAdT9+dXcFdyCyhDWPRe5l60nBzMVz2pknfWAs0+5bFQxF8rm5Jz3kN1jAPH5UJzphKB2BdCXKtfNOq3+0ZW6TXm951zwgG+LIlSUcfJzDBDvX3sHKl7aFCQLZUB5bPU6hkYQwkABieU65n+v9MdHOy9iQkIts8tVh4oyMWTT0H8BzfpYLjcN57T7dcuA/xvniMkTYPwSzz7ngYBYs9ibZr7EAMSMX+ZYEcqFt5xRmqtFQJtCFN4SrZWuAXYGNDcj64yHLDgNFUzhtiA92FtPSseVXwJRUawRLXWVy4tuuaAkRwtXv3LoCnjcveKGwPgCRdd34W1n2X3AN7oIIZ0sBy9K1mEA0LpVoLxYvL2K7hh93Qw6DoDyqz0v1RUlWaLoKM12ws3f/BCScFceLGPeNZlf+ZCX1jHFoBfnm1qYywstb3NBbzy3+WnGh9TlTdYHphh0HGDSdWxqOZVcYwBx8B4A+LUqhGd4CTJPeVkd2a6Wdbksn8eVrWI7mg3JkNN1V0XaLvX4nqYv7xajLS2WeVfd0KTrXVl4m6LXiaPLpe5HXYEGqTsC4NFEaanRl/G4vCVQtmpVhzt2+KzmpSpfrqYfA4DSKpNlYi2S/NBtUXTHeG5K7YnEYYJa13hJlhZFZuMIss54qvrWmwogU1/izNMeyDrthaYDMnHnuHh8zF/kd457Iai9setW+ngxpbpCWbIcF9xwRdqexjfIqCRb/eOkJkj7ClQt0GrKNbN70vw6Nu3Wr4mbhRrmA8sMeia7CUlc2WJ8zkkfDBLqg5tt88eP9g3CL85wxsUNtRuwb60XwV6kD2l7fKEBZY+IKZI12RzT94ItKoptyM/GNfYaAA3wqzMi/MQLJsjTBa8/EA8XbR1+J+1/H7hukuzg9mkxS9XPc8WwaFvni9ncrFGcA+SbONQfXw7olMI4M8XL4gWtimnGLxXKSzicW90EORfdcH2vv3zjX9/rj9Qdll30WWc8rI7CN/XrykwxPkCubFXPOJiX6qq4QctyjcIgdVsgyos5XP45GNnnPFF4yxll+RoYKoAbB3wVfle5F93FBGunPZD+P3HAg66AV3R3lptsx/QVYL6P+ddckX7Y1+IlWHpXK1s+JX8/oDIKSGUUB7XDcuH7JkjbHaAYpKc2AFLydQaUgkrNn1niytYg1Wvg5m9+8sAUU3LOe+DajkCbIaBMLUTZ5zyQttdPIR6v/hJk1U/OFHsFdfohdfGYn2ZdVJm+aHMvu8FQziH/mqVlSJevtWsAlfmAoJpgbqGVPnyA6gsq05emrqD2XaGpOwKRedLyhZ59Xtlm82N4yURESML4msozQSLnD486i2gBAEW3770BqH9F1IwFjqY2kSMaO2r3cl2Tl1Y3H2+1gSzLDmZ0+yaY3CUSLYM9kX63jvOb6yvETEY7K7MThbYDnthnTJtacFt0tTjymXriDInFzWHPp5xp1ydg7HpizNjNzmsF0TK4JRhhPXOgddejLE8Dn2bisSiqFHGmL3fT7qqyPA2cPI3d9ZkpXhZWPAk1/1dAFCMZJz2Rfc4TgfFGy5O5lc1UYANAebHxg6Yk2wk39lv/OJAGLkkU3HCx2s2q1zHF4T23ugm0lf5f1qwYpnXJPtoQreQu/qLVuNxGuK26EhHmIq2q+dUhoxYP5YpS+z5GrQl3WwPDTKnKUmnL7/NexB7LdV1iahUnCOLe4M4xHzS2AJokllX49Yz64BJ7+HBSB/m3n7vjusxUWTlGmbjj1kkg+Rsg+6I4XZYP/Py8HRXVrM/j/JomcPHTwb9VIW4e9INbcBma9suWu/duH/WW/am8m5bg+v6q/Qel7ndr5F6y7utlimQtMxfEtrh50Pjir674yzhpvSvdtKtZojrWxWIzQVCaLYW8q71AJQiCIAjCNvdu30EteGLFsRqtNyS2jpOHpKwDtv3dOG0qlCU2P6uctjGwTldoGedRQhCgGtRe0ItRBG79TxSHpTlOslWuNEfshpasTaYDD9L2+NdooA2g9HMzDztWU9QGX9j0oSIIgiAI4i8JqQMHceXNYY7L0Hhhq+hH3OFBcfr0j8DtU2JkCQAYVHUu+NK7Gjh7VoDZ6J2+8ksghApOEUHh7lVXlGY7wdmnXFWY5lx0VwwgMsda9qDapC6tyYALgiAIgiAIR0Bi2UFwnANHTkupjyWxvO5R5fL/fQnEjrG6enkRh6u/iO4MTbrlqgb+Ly/mIKgM5pLCCrkFqYdHszWQwVDO1UoUEwRBEARBNDbIDcOMCr31bDd1SnmJGMXCnOIcy3lbXgBWjbdalemAsPTDvijL08jpdytKOAgGZbic/Osu0BXwirS01kSvLasyQRAEQRDEvQZZls3QW4tTVtdsmA2cXgfMu6Kcf+Ooevn0E1arMk9xbD5ozq9VoSKhgXlcSoIgCIIgCEKELMuNhetHxP+73zBbYNu9o6KUw61kb0V8V72tLGyAIpsPQRAEQRAEYR0Sy7WEY8DLw1pVf8VNzwCnfzBOV6aXRvJX0OsYKko5GF71BtKPo/C2M0pzxdjBV38VMyLpCnkUpjvj4k8huHvJHZkpRveIjN/rP4g4QRAEQRDEvQi5YdSSK28Nr9mKx/4r/sWNA0qVqZP/WB8iu0k0ub4E6YctE0xIKZwlci96wDOiFO5BOpTl1T4LF0EQBEEQBFFLscwYWwRgNAADgAwAjwiCkK5STg8gpXIyTRCEUbXZbkOz7m/d4erEw9etGklHKsqA14OA4e8BnWcY5/+xzTI2sok/cWG6ZWxifbm6a0bargDRH5kgCIIgCIJwCLW1LL8jCMKrAMAYexrA/wH4m0q5EkEQ2tdyW/UCq8JHGAASoqo/IE4oyUPmSU94l70J5ziTSBbfTgAA3E72hpNnBfxiihTrqQnjiz9ZT35C/sgEQRAEQRCOo1ZiWRCEfJNJd9Q0b/K9TlkB9IdWIfucJ/Ku6hHt3NSiSO4ldwCwEMtqWe8EvQNjOhMEQRAEQRBWqbXPMmPsDQAPA8gD0M9KMRfGWDKACgBvC4Lwk5W6HgfwOABERkbWtmk1Ir+03LEVnlgJbHgKQgkHIKTKrwmhgcI8EwRBEARBEJZUGQ2DMbaDMXZa5W80AAiC8IogCBEAVgGYbaXgbEo8AAAgAElEQVSapoIgJACYAmAJY+w+tUKCIHwhCEKCIAgJgYGBNdyl2rHxdwuX69qx/R9WF5XmanBudROUZBkH5J1f28Sx2ycIgiAIgiBqTJWWZUEQBthZ1yoAWwBYqENBEG5W/r/CGNsDoAOAy/Y3s/7Q8A5ycbi0E0g7BBRnQa9juLRB9DOWateXM9xK9gEApO5omA8DgiAIgiCIxoR2qL2ys/6obTSMaEEQLlZOjgZwXqWML4BiQRDKGGMBAHoCWFyb7dYljDlALBv0wMqx8mRJtknUDAaUF/GKdNMEQRAEQRAEYOjRsaGbYEFtk5K8XemScQrAIADPAABjLIEx9p/KMq0BJDPGTgLYDdFn+Wwtt1tnrDiUWqP1Sk78jryf1osTC43RMgpvOeP6XmWcZBLKBEEQBEEQliwPbXyOB7WNhjHOyvxkADMqfx8EEF+b7dQnVzKLqi6kQurkyQAA7wfGKObfveymmK4o4WvWMIIgCIIgGg257oBvzSSDXXw4ioNvIfDwrj/HyP8vB3OY+Wvt27rvxj4HtMaxULprM6z5LH84yc4w0TlXkX/dBdnnPJB3zRUFN1wd2DqCIAiiIVjdx/rr8myE8XdyC/td+SYusM9e9Uctxn1frezIPHaf9XaVOAFptRg6s6w/h/+bymPmHB4zn+at7tflEHGfH322fo1GpTaS2p4PM/5+8VEek1/ksXgch+nP2G5jqRb4qbvxmvjHg5blF0yr3X7+Fsthc9eaybSd7ayf758TGPbFistzbKRm+LZv9ba9vSOHj0dy+HAUh71xDP9rqd6GudNtHxehEUYhJrFshpZTPySj24epzrfgo/a4+ZsfMk56If2QrwNbRhBEfbCiX/0/Fm/V4lHx8Uj723vDv+oyahyJYZj/CI/veylfftcDgLSAmtVZHf49wriPx5szvDaleudofxvr6xQ5i/9Tg8T/xSqJWT8ayeHHHuov/o9HcDja0lj32UimEIurEjms7cXhidl8lQLMnIkLNJi4QIO/T1MXn++Orfo4vPSYBq88zOP9MeplC1yAaXM1sjxZ24vDrx0ZnnlcbGuWlzj/dCTDdZNzvWgShwxv8XdyC4bzEQx5Hgx57srjtLaXcbsLHhX3o8jVupBbMtr+cysJvWuBwLHKjxSpTRJS+0156VHjeSh1YnhyFo9/j+CQGsKg5xmSW3IocGN4ezyHdT0Z1ncX617RT/woePlhHnP+xoOZaLp0P+Bga7FcahAw/Rkel5swfDJcfX8WTlbOXzqUw/HmxuOSb2JnMxe079hx3r8eJJYxMGDG0zyeepLHxPk8npjNY9kADp8N5zBrFo+/zdHgrQli2VWJxnoNDPiph+3tPPWk5fW8P47Db7EcPhnJ47Nh4vo/9GDyRxsAXA8S75HnZlquf8MfaOHTosr9q29ILJtha3yft6sWXZtVP3sfQfzVyK/jDpUXVCwTWzs5JpLNpm7Gx+KJ5so6JUFlD+brSqQ0Vc5Pms/jmb8pxVCJimBTY+ICDfbHGdu7v43tY/DlEL5Gx+lsBMOVUIbve/M4Gm1cf+5MDV6YqZGFlTlvjze27Z2xHKbMEwXj2l6cTYuWKdOe55ESZdzm8gEczjblMPlFXhYnpuxqK84rMzmkH4/mcbYph4nzLdtZWHmtvjeWx6JJHObOtDxGB+I4gDGcjLLc3uFWynl57sbf67szbOjOYV1vDrmeDAUm98WcJ8S2WLOynQtXTkuCxpT/xYjzsj2N856fwct13q30ArwYxlCuZaqWzpcfEed9OoLHsfsY1vdg+GowL0du0mmAh+byeGMShzcn8vhmAIeJCzRIacbh3bE89rdhyPCxbL9ksf2xZ/Wut1u+tst/M8B4HN5IEtvOBOBm5Yfgh6NFy7YkKK8GW9Z3NYQpLK/Z3gz74i2P7/FoDmv78FjTh8PXAzls6Sx+FFwKEz8M7lR+5H45mEOeB4Ou8ppb10sU2wCwty1nYdX/rg+H01HG7SW9xGNnew4r+ovz/tufw4xnjRfwnCd5PDSXl5+rR1syfDyCk4/FznYMjz0jCuGlQzjMe4xHuUYUpJPma5DvzpDpwwDGkOsp/tfzDFneYrtOtBDP6YbunPwBVmiZD82CTB9xG18N5DD7b5bXVpGruHxNXx4LJ1suvxnAFMaJac/xeOkxHsl3kqveeD1T66Qk9xr5pRUW857o0xwAcPIfg5QLUtYBzp5AyvfyrPIi8kkmjKzpzSFpf/34m30zgMO2jgzfLdbbLKdnAG9nL9eRGIauF6rfJbbkAQ7/95243x+O4jB5rwFBeeplb/sAIXfFF0abNAGcALy62vYxSwti+M8gDjO2Gct9M4jH4VYC/rnKuP86DeBkckuv7sNh0j7jOpNf5NHlDwHP/aTc3sLJHPQcw40A4KsPjfWdbsoQli1Aqxd//2s8hxfXGRB/TTxGWzsxhGcBb0/g4FUCfPaJ8lx8OEq0unQ/Z5C3KR3d6c/w8rY+Hc5h7nplm7a3Z/i1E4dFK/Rw1akfl8uhDL3PWp6vpUNFK+C5SAb3Uoahx6p3Tk3F0OVQhs4XBavLTTkezWH+IwxFzsAdP/HFXKAB1vVmONiGYckX4v4mvcTDrwDwKwDy3YAsb8jXcYkzg4vOuL10f7EePS8Knh7nBJyOZIhLE8ss78+hyMWAbxM51XthV1uGvfGcfJ18OpzH5L16ZHkBd3wrxcpADuUaA0YdUe7n2xM5xF4TMP97AzQG4NnHeZRrGUyT156JFNun6orAGB6ay0OnAQROLHc9yCikVvbjcC0IcNEBR1opxZsoaMR5a98yXtTvjeFwqQnDoOMGjDkkINtLvO5PNGdY21tZx+VQ4z39z8kcsr0Y7lSK06shDP+aaHx/SVZTAUCZk1gm2xvY2tnY3tQQho9Hq7/z/u9h++TFDz0YfIqA/ieFyjqNy95/gINniXivffiFHoUuwNbOHHa1Y6jgAd4girrvEjn83pzhZDMBF8PE9nGV7TdwgF7FLPjNQA7BuQYsG1C1zdDAMfySYCm6j0VzeOUhhouVHwbL+nPI9jQoPigBQDBb9SezXgrpWrgZwPDEbB65Zh+S5Rpx+dyZPPzzATCG/fEM/U8Y5PoLK8X5zg61Mxr8L4bD0iHiMTdl7gwensUCXvvWgNs+Suv8rwlVH8MiV4bH5/Boekd5T23qxuFgawaXcqDEpfFmJyaxbAdTu1mmpwYA/DAdAFBemZ0PAG4le6uXJf6S/NiT4VQUjzdWKF/aaQFAZJZjt1WmFQWEGgsnG8XrJyM4PL1JKcQWj+Pw4g/ivDIN4Fz5Lq7gxK/9t/6rR5Ncy3rfmMgh3Z/hzWV6eBeL80q1wOkoDnOeYChwA4pdRGE0/oABEw4YH5Rvj+eQGsyg54CoDAECx3Cm0nI37XmGZe8rj9knwznEXROQWXmLFTtbtudcpHL/F03m4V4iYP46cd82dGPQaTg8vMuAT4dz0PMMh1oz3PJliMwUcK1SuEhWH89i5YO92JnhpUc5tL0qYEsXscylJkD8NXH5N4OML5BsLTBzDo+wbPEFc6gVw2+x4jqHWnM43IqBM0DuzipwE1+UAfnAxSbi/kZlCOh4SUBoLnCyOUNaEMO0uRqFWAKMwowJAh7ZaZy/qy3D/adED8CUZuK2j0UzrErkcCCWWYh5iVen8li0Ulz29UAOx6KNL8NNXRi0FQw/9jTO0/MMKU0ZjrVg2NKFU7TvSqj6NSmJXkAUC9neohhTo7TS0r7NTAhkeYnTZ5oyrLifg2eJgGIXhhX9xfNw20cU9zKM4fPhSnF3LpLh/x5SvgoFxnDiPoZRRwRFl7eeZzjVnAEQr6c7lR8Je+MYpu2U1lXfBwlJeKqxsVvVosMcSVSv7svhxx7G+t9KUhGxjOG9sfYZdCQrqXSMa8MTs3k4W0mOu6av2J7+J8VrRmAMOR6AXyFwuLW4b7xevA+/r3TpkPZRzwOPPWc8dynNjG09G8lQ6AL81I3D2t5A3xTx40dyDdBpGRaq+BlXl4vhxm0WuTJ5f0ypqJy1KpHDgTYMgo0u7FxP68vy3Jmi50K61piDXXx3djBehxu7ivfB9UCG0GxxXqFLzYTtXQ+Gux6W62V7N16RLEFiuQpigj0R4edms8zVX4wjI4pu2dF3QdQpGd6wasWUSPeFqvgzZ+lQDk9sNWBdT4bxv9l+Ir34KI/F3xjFx6PP8hAYw8Vwy7IvzNTAp1DAFx/rLazPS4dw2BfHsOpd2xZic4rMLr3JL/Lofk7A6MMGXGxifBgdiGUocebw0jrjNpNbcpjxNEORCxCYBzy2zYD2V8X9LXFhslj5bBgHPSd2lQbkCzh5n/hQfeYJHiOPGDDuoID8yttFsiQC4gvweoDSAnfXgyGn8kV80uwBWuJsnP6/qTwC8wTsj+Owt636vpu6PCyYxmPRCj00BiDPDbgQzkESN3qeYXNXZjFoJjWEITXE8oEtvYQKXYAfeoq+nBUahhuBxrJr+nBI9xPgV2jZLtGHU7Q47Yk3tzYx6M3eq7meDLmVXep72zLsBfB7cwNeWWPAJRPRd6I5w20VP2eBMZyJBGLTRCFn4JT7IZXZ0J3JAkSNy6HG37+YuSSUa9UFwaIpju1Ve28MJ4uMEmfRKpVv9ii+5c8w+288Mn1QKUCUbX36yZq/4s405TDzaUsfXDUK3UQf376nDRZWQXvY2JUh2I7nkS0ExlBmp/uOPWT6MHwwmsOpZrUXMrYEoMTPnRkGHRevyXnTefiY3E96ntk9GFKiwI0phPTK+3msvL9aVTiMrwaLFudNXRkMnPFYfDmYw+jDNe95lCzmVX2g1QbT43bLT+z9OFCFu9e9CInlKhjeNtRyZmkecP5neVJfRq4XDcmqRA5NsgX0SxEftLNnWVreJApcgOnPacAEARo9sOodS0H68UgOcyotr7vaMRS4cjjWgmH8b9bF600/UXD90QRoWZkx3dYgFkAUixMXaOBVJCBpv+l8VHbtKlk6hMMTv1g+WNf05pDnLnavmqLnGQ7EMdHfEqIP4almou/lsWiGYmcD3MqM5fMrRcFtP+DD0RwWrtRjnTQ4p7Lq1CCGq5Wi7aKJMCl2YdjchcO4g3qLLkiJ000Z8l2B39qIbgB3rHTdm3M+QvQTNEcSJQaIbg8Sl5swZHoDoSbi46uBHKburv5LSc64yQE/d1G3+hk4hr1tbZxrxvBzl5q/XE42N3a/S6haDc34bBiHHufEe4JT0cV6nmHaczw4AfhmiXht/96Mof1VAQIDnpzFi9eHIxI11QBzNwQ1ixQAZFTh41ob7BHKErf8GVarfETYw8r7G+c75FCb+hvWtGwAj2WVidsK3MReqXuFPHeGZQMtz/H2jhy2d6z5MT4Qy9DsDpMt7nUOY9jY7a8nlAESy1UysI1KApGfZgHnNwMAKkppjGR988EDYjd4ZIaA6FvivM9G8OAEvSwO1LjtAyyt7IITGEO5Bpg1i8ennypF8P44o1gWGMP/TERorrvo7hByV1n3ls5ivX+fZl2oWyPf7IUshTk60pLBvVS0SriVAhfDgJsBPBauVLb3BzsflOY+hI88r4GzTlDtwityZZg70/LxYOsxWeTKMONpXjGIyZRCNyYPWvlmkHoZU1KaMtkXWI0zURz+OVnsRhc42w/wXxM4u/zqLBAU//4UmJ7P1X048AaDhVVbQupKfWsCh2JnhtRgICBfFNLZ3kB2Ddvw2TAO3nUYf7ah+WyY2Buk5gtbH6zvztDp0p/pqiTqAj3P8F8VEU44HhLLVSCYP4/KS1Fx5TjyL7jD2accabvrIW7Sn4gSJ1gdfCTx0iM8nvhFD/98yH6u1rgeAERU+vauSuRwKkq0bB5qDQTnCli4Qo8DlfEiPxnJ45ORYtnZf+Px78/1iqDxal2yWSa+UhdDgW9MHjw/d1YKjAXTeGR5A13PC5ixzYB5j/GIyBRky609bOzKMDTZ8iV3NJohPlXAivs5nKkcWPHeOMuH4HmTeK6mkQZMWdObQ/Bd+16ktvwnTZFqq8o3zlz414Y3JnHgqzAGn4lSPwb74kQxY95tX12YxY/Gz489OLRaY8C1IIYiV4alw6p+mZ5oYTyONx3wSNvdzr57It9V9MVuCBZN4qplOTZlfzyH/SrRE+qL7xJ5fJfYYJsniL8cJJarIDrYzAFt7UNI21COsjwayKfG357isewDpeVzbS8OEw8YVc/VUIb5j2rQJFuQR8Or8dVA0Xd32Qd6bO4shmAy5Y4vwxNPq1/C0iCIPW0ZxhwScNOOiH+vPGKsS80/7nKl3++2TgzbOoltuaYSlsgW1vzm3hlffevA8Wj1l7W9lubqUJc+cdYwcEz2ua0uP/Rk2NiNl0eR15R8N+BSqOiX/GfhVHMOkxb8OdprGh6rvpEGPBINh3lMZIJorJBYrgItb/ZAvbgNZXm1SKd0D7G9A8N/BnNY/JUeTTPFeWojZNf1NorlB+cZRaHUXb+hK8PoyhBN3/blMGWvWFbqNq/uwA5AtJhOfYFHuQbY2BUot1HFl4M5VZ/YmrJoEoeAfIdV1yhYMprH8KMGXAmpumyjoNLNprYYOIaXH6HHJEE4mlen8rhNaQuIPwn0FvgLYG1gWG2Y9jwvRyyYN0ODficNOG4SeH1TF4ZeZwSLcEGmlr4CN6OP6/44oMsFAT/1MIrl2qKrHCRXVEWCjNoMsFDjXrRYZfgyRVg0giCI2nDBgQYKgqhrSCzbiW7fajB3H9zcWcN8sQ3Izg6i/6aPnQNufujBMO6g0jl1yWgOGd4MXsUCdFplaC9A6aMoWYJX9qvab1bycU0LEhNN3KuYJ8eoDcXOgHMVfuEEQRAEQTgGEst2cvnxf1b+UsmE8CfgpUd5LP23fXF71/TlcdfdgEd3GOSQUwflEEL2C1rTCAU6HnCqXtjge4qZc3hoHGTcn/E0WXgJgiAIor4gsWwDjST2LEJi/PnI9WSo4CALtlcf4uGiE/DKGqOCe3MiB48S8bcUamv6r3pEZNZ+/2c+7Tix+GfEkWk8K2o5aI0gCIIgCPshsWwDN6dKC96d0w3bkBpQzgPru3P4qbtRWE15kcej2w042IbDhXAx29VDcxlWvFeZkOA+S1/brwY7xorZmHO+EwRBEATROGjj36ahm2ABiWV70FtJat9IWTyOQ3JLlUFmzHKQVgX16BMEQRAE0UgwCI2vG5rEclUYDMC+dxu6FXbzehKHU83tj8ag5xkWj+PgQgPGCIIgCIJoYIRG6Pp678W4cjSXd6Jo//aGbkWVPPs4j4kLNNUSyhLJLblqZaGra96awGHeY2TyJgii/vB2vvczZIR5hFld9mzHZ/F6z9drXPdXg76q8boNybqR6xq6CXVGS9+WDbLd9xPfx8mHT9Z4fReNiwNb4xgaj0JqhDQLcEfJjrVI21U/Ka3vmqXmPW/9uabgYGuGdP97xyf4RAuu2pnxCIIgrLF+1Poqy3yQ+IH8+9P+n1osf7Hzi+gT3seh7QKAFUNXOLxONVKmpWBRz0Wqy3ZN2IXp8dMxusVobB27FaPuG1Xt+kPdQ5EyLaW2zURSTJJiurVf61rXqUaQWxBSpqUgxi8GQ6OGyvPHRY/DsiHL5On9SfsxLnpcjbbxYucX7S77Yb8P8WG/Dy3mv9b9NTT1alqjbYd7hMvTw5sPr3KdDkEdqrWNrqFdLea18GmBgU0HgmMcYnxjVNfjmbox7OWuLwNAjfa3riGxbINvprRGxbGN9ba9x5/R4KknefzejOHh53n8Ea4UjKcjjdM/J4i/1/Tm8O8RdBoJwpFoOW1DN8HhtA1o65B6mns3d0g91cX0nPw2+Te0D2xv97otfFvYFHJtA9uiU3Anebq1v6VA83XxRZeQLhbz3+v7Hma3n21z+1NaTVEIMIlXur6C9kG296OVXyvM7zJfddnmMZttrmsPXk5eCHQLlKfDPcPxRq83VMsGugaqzgcALS+eH38XMRfBkn5LMLnVZEWZXmG9qmzPyPtGKqbXjlyLHeN3YN3Idfh+5Pfy/G8Gf2PVKpwYkVjldv475L/y79d7vY7t47fj+U7PY17neegY3BEA4OPsAx8XHzTxMGbtnR43HQDAMcv37rQ20xTT7QLbqW5b7fnSKbgTNJzSMzZlWgrGtRyHf/b4p2K+6YedNR5q8xDe6PUGJreajNZ+rRXXt8TApgMV94WW06JzSGd5emLLiTa38feuf1dML+yxEJ8P+Fye9nHxUV3v94d/x/Gpx7Fn4h5sGbtFni+Je9Pj3VgglWUFHnr4fVT/L4VMH4Y3J/Eodba0rK7pw2HG0zyeepLH6r4c1vVk+Kk7o1BiBAHxxTI4arBiXvfQ7nata/py9Xfxx7Gpx/B0h6dr3aa3er9lMW/50OUW8xKCExDgatmDZW6Bea/vezVqx4f9PsSq4asU86J9o6tdz+YxmxHhGSFPz4yfiaUDlirKHJlyxK66/Fwscx1Lx6uVXytF+zoEdcCRB49gdvvZOPrgUXg5eWHFsBV4tuOz1d4HADgw6YDi96phq8AxDkemHMGPo35EgGuAQui58C7oFtoND7d5GBtGb4AT5wQAeLfvuxjYdKCi23jH+B2Kbc3pMAcLui6QBRgARHhGYP2o9ZjUapJq+0wtwNE+0ZjcajI+7f+p4tgDSguc6T5JvJDwgs3jAACM2X5/zGo3CwDQN7yv+vL2s7C4z2KEuIcAALaN34ajDx5F/8j+eLnryzgy5Qj2Je3D7om78dH9H+HNXm/ih1E/WN0eB85ChAW7ByPGLwat/Frht8m/4dDkQ0gISZDb3sKnBZYkLsGBSQfw7bBv8fH9H+Pkwyexffx2LOyxECuHrcS46HGY1X4Wto7dipRpKYpj6cQ7IcQ9BI/GPQp3rTsAYG/SXmwdu1XRjpnxM/Fsp2exevhqbBu3DccfOg4tp4Wbxk31WAa4BljsCyBay49MOSJb0VOmpcDb2Rs9mvSQrfovdX7J6jEa0HQAfhn3C17t9ioAoFtoN8Xy74Z/BwDwcPLAy11fxtqRazE+ejzGtBgjl+kY1BHvJ74v7ysATGk9BV8P/honHz6JlGkpeLX7q3L5CM8I9GzSU54O8whDlHcUjj90HAAwovkIjIkeg2D3YLnM+4nvw9fZF2tGrLHYBy2vhb+rv+I89ArrhY/v/xhPtH3C6r43FDTAzwqfa6v+cqtvUoOBMifjzbi2D/n1NnbcNG4orihu6GagfWB7/J75e71tr3NIZ8xLmIeJm61bJrycvJCvy5enVw1bhQe3PGi1/MphK/H5yc+RX5aPV7u/igmbJliUebfvuxAEAduubQMAzOs8D74uvui3tp9qnQcnH4Qz74zskmzsub4HgGjZYoxhZtuZ+OjER1bbs6jnInQK6gSe4zH4B1GkD4kaguHNhyOnNAfOvDMGNh2IBfsXKNZT6+ocFDUIk1tNxu2i2xi4bqA8v2toVxxMPwhAFLz3R94P7LXaJExoOQHf//G9Yt5nAz6TX3If3/8xYnxjcDbnLDoEdUDfNeoC6MXOLyKrJAtfn/5aMb+pV1NMbTMVe2/sxcf3fyx/ZHhqPVFQXoAtY7bATeumUiPwTp93MG/fPACQrVnxy+IBAIcmH4Je0ONG4Q0AAAPDj6N+RNLmJJzNPosXO78ILafFE+2UL9Hp8dMxrNkwuGpc0XtNb/w67ldklmRizfk1eLzt4xj5k9JK6cQ5QWfQKfyTTX+7ad1kkb6gywLMTZiLCkOFLKAAoLlPcwgQByAlRiSCMaawCGo4DbaP346SihI0826m2P6KoStw+e5ljGup7NZfN3IdCssL4efiB3etO4LcgtDKrxV2pe3CY3GPgWMceof3Rvcm3SFAwPiN43El74qiDleNq/x76YCl6BHWAwDwbrJxgLpk9TWFWUk0tWzIMvAcj/iAeDze9nEwxjDg+wEAgA2jN2D0htEAgCfbPalYz4l3Uky7ad0U14S55RgAfJ19UW4oR2F5Idy0bkhqlYSV51bCy9nLoqyXk3Ge5IP9WNxj6N+0PwAgPlC8pjjGIcQ9BGOiRYFozcprDdOPuUmtJuFCzgVMixUtx7EBsfKy4w8dx+W7l/HO0XcwudVk/PfMf+VlphbkAZEDkFGcgVNZpwCIx+Xv3f6Ov3czimkNp8Ebvd6watkHjNbXMI8wjG4xGqcyT+G5Ts/BmXfG0dtH0S9S/VnHGEPv8N5Yf0l0SXq799uKfTW1MJtazbuGdMWR20ewZewWXMq9hN82/gZXjats5ddyWhyZcgTOvGXCNi8nL+ybtA+AeM8vObYEu67vsrpvjDG7egUaAhLLVhjIH4eukEdBev1k7Lvlaznv144cRh0RYyC/kcQphDJRO4LdgnGn+E6db2f7hO3o+V1Pi/nJU5NRVF6EsooyPLfnOZzJPlPjbbQLbIeTmZaDKf4z6D+YsW0Glg5ciu6h3dF2ec264XdO2IlB6wZBL+jRK6wX4gLi8PnJz22u827fd+UHcL+1/aDT6xDiHoI/cv+QyyzquQjH7hzD8rOipbVtYFtsG7cNO9J2YPHRxQDEB6wkqNoFtsNnAz6T1/+o30d4erel9fe9xPcwcv1IpOangud4BLgGYMvYLTh6+yj+cfAfAIBnOj6D6XHTZUtQqEeovP5znZ6zul8PtHgAMb4xOJV5Cg+0eECe7+Psg7tld/FO33cU5QVBQLvAdhgQOQBt/NvI8UO3j9+uEMXRPqJAC3EPwecDPkeoRyheP/w65iXMw5iN4sveXISYcmzqMVzLv4bt14yDkWe1n4UOQR0UVifpRRTqEWo1PJMsygFZLD/V/ilEekYCEK1YyVOTFS/H7RO2o1xfbtHtumP8DgxYJwqsAU0H4NDkQ3J3vYS/iz88nDwAiAJiUNNBsige02IMzmafRah7KKwhnTvpZd/Eo4ksjP7R/R8IdjNaulaPWI19N/ZZrcsUxj2bh0YAACAASURBVBiceWdVESCJZUlojm85HqezTqNzSGf4u1oKUon2Qe1V3S5i/Cx9O1v5tUIrv1aKeZIoXz1iNUorSgGIwpgxBifeCR/f/zHiAuIUvRTbx29Hdkk2AFHofzf8O8T4xWDP9T14fs/zqu4EABSWcElPS/vrrnXHMx2fwY2CG1b3tTosH7oc/q7+OJR+CPf53AcA2DRmU5XruWvdHeInXRVeTl54L9F6r859Pvfh84HiMzFlWgqySrJwKP0QAt0C5euhjX8bPBL3CKZumSpfP/YifcD1De+rELnOvDNe72UclGlNKEv0DuuN+yPux7zO8xTPPFv8u/+/ZaOG9LwMcQ+Bp5OnXMbaB7I5z3Z6Fs92qllvUENDYtkKJdlapG637p9VE/5oArRMF39/OVh8QG3vyKHfSQNORVkK4UwfMaybfwFwsgZRLgjrLB24FA9seEB12bjocfjhothNePyh49AwDcoN5ei0UvT5GnXfKHQN7YpXDryiWO/bYd9iypYpinlaTosDkw6g12rRV++LgV/gZOZJxUt49YjVsiAExAEuqfmpOHJL7M6O84/D6WzriXFa+LRQFctdQ7tW+SJx1biipW9LnMw8iQDXACzquQghbiHI1+Vj3r55yCjOgEEwoKVvS5zLOYfZ7WcjNiBWFsuPt30c0+Omg+d4pOalYvym8Wgf2F5hldk9cTcAYOXZlfjX0X/J84PcgjCv8zz0Du8tW3VDPULxUJuHsPjoYoUFSY1+kf0wt9NcvHfsPYvuaXMxE+EZgQjPCJzPOY/vzn8HV42r1e5nNfHgqfXEo3GP4qE2D6mO1F49YjVSMi2PNWMMK4ettJgf4h6CSM9IpBWkYUm/JUgISZCX9QwTP66+HiwK1cFRg/Fr6q+KLlBTRjYfCSfeCdG+0Qh1D8VnJ8UPik5BndAl1NLH1nQ/P+3/KWbtnKWYLwllQOzaP5V5Cr3DeyvKmAtId607oOLmHewerLgGJVEssXPCToVFVMtpFaIkKSYJSTFJVboKWGN8y/GK6WjfaIV7R4190yu1jnR9OfPOqi43dYWrxlU+bpIFGVD31Q1xD5FdJAAgLiAOQPUHcwFiN/2S40vg5eyFGfEzqr2+GqbXx6CoQQ6ps6EJcA2QLej9I/tjSeIS9I3oK3+0mN5j9uDl5OWQjwIXjQs+vN9yEGFV60jPPOk+vBfHdFQFiWUrOFooPzGbBycAn32iR76rKJIldrezLoRVk4sQNWZWu1kY3nw4Ir0i8cu4XzDkhyEWZR5s/SAiPCOQFJMkPxSceCfMajcLsQGx8oj4L099idT8VADAfd73IT4wHg+0eAA/XfpJrkvDNHB1NoqB7k26o3sT2360vcN64+/d/o5V51YhwjNC3p6poDYlNiAWP1z8AZ/0/wR3y+5aiHiJwVGDMTRqKPo37Y/TWacx+efJWD1iNZp7N8eh9ENICE5QWP1a+rZERnEGtJxWfkiaW0TmdJgj/47xi8Gbvd5EjyY9oIapLxtgjKXZLbSbhc/dlrFb4KkVLRdqvpgS3Zt0B46J7g+mdAvthmv51ywEt9QNXZUQN0fDaTCz7Uyry8M8wmyG5VLj57E/21Xu3b7v4t2+xq70g5MPosd34jFOnpqseHF5OHmgU3AnHLtzzC6B2SusFxZ0WYAR940AIPqLmuLt7G0hlO1h3ch1KCovqrJckFuQzeU1Fcn2sHXsVrstYuZ4OHngbtldWPFg+FMg9VTEB6g/V9SYHj8d0+On11WT7kkYY7KLSLB7MA5MOlDt509joZlXM8yMn4mx0WMdWu9Xg76CXtA7tE5HQ2K5nsj1ZOD1ojj4vjcJ4KfaP4VPfv+kWut81O8jXM67jA+PW/8y/mLgF9iVtgurL6xWzE+KScKaC2swIWaC3EUZ5hGGsdFj8ePFHxVlGZjqC+HJ9krfvBVDV+CX1F/wxpE3wHOi//iinotksfzFwC8supyt8fXgr/F7xu84n3Me3ZqIwvHB1kr/3Rc7vyi7JwDAE22fwGNxj8FV44pOwZ3kKAVdQ7qiVF9qsQ1TwRUXEKewVKgJ+Hf6vIMz2Wfg7+pv4df4TMdncDrL0tqt5o8oYS2MkBqmlmJb8W9j/GKwZsQai7pf6vISpsVOs+gSfyz+MQS7B1sNo6Q2YhyoW9FWXTydPPFmrzfh5+Kn6iKQFJOEY3eO2RW1gjGGKa2nVFmuuqi5FTQ2wj3Dqy5khRVDV+DAzQN/agubl5MXvh32rez2QNQPf+Z43owxPN2x9gOfzbHVA9ZYYI0xUwoAJCQkCMnJyfW+3aj5orVn609VjyKuimuBQNNM8ffEBX+N75Lm3s0tBp6osfGBjdhzfQ/eP/a+zXKmotp8UJA5/77/3+gb0RfF5cX45PdPZF/Yf/X+F4Y1H2Z1G1J9rf1a41zOOexL2gdfFxUnchUu5FzA+E3j0dK3pTzCW6rPVIyqzaspjqzLXk5knMDCQwvx3fDvahUw3iAYsP7ierx26LVqHef6IF+XDxfeReEbfCn3EsZsHAM/Fz95xDhBELWnIZ5jBGELxtgxQRAS1Jb9NRRcA7FwCo+vPtTjjaR7y5K8evhqTPpZPeTRhgc2yL9n/DoDR24fQcegjrhbdlcW0V8P/hrNvJvBiXeqUiwPbDoQx+4cQ+8wY1fw2OixEARBHtW7evhqNPNuJnepumnd8HCbh7H87HIEugbaFMqAGK8zyjsK/i7+KK4oVox8rwqp693Uf29c9DikZN1bL4AOQR2wfnTViR2qgmMcxrUcZxENoDGg1jUqDVizFjGAIIiaM7DpwKoLEUQjgMRyHVLgxu45i/LRB49axBS9XnAdZ7PPole4MuD8fwb/BxdyLiDcMxwuvAvarxBHgUtBz8M8wvB8p+cVgvndvu/ihb2iVV+yOHw56EtFvVKAdkksm4bxkZBG6poP8FHDdHBVdYQyIPoumltGXuvxWrXqIBovjbXnjSD+7ByecljVjYggGiP3lpJzEK3ZtYZugkN5NPZRfHPmm2qtE+Iegj5hfbD2j7XyvBVDVyiEcmJEIoLdgxHsHqwQnKaY+i4mhidiz409iuU+zqLlLtY/FokRiRgcNVgWy/agllELEK3LJx46YTWt5p+Z7eO3Ww37RTgWHxcfBLoGWs2gRhBEzaiuYYIgGhISyypsdV6Ac6hdusWlQxqP68XzCc9XWyxvHy/Ga5XE8oFJBxQDEw5POWwz7qsaH/f/2GKeZGV+IeEFq4LbGslTk22KYfPUofcKpmGgiLpFy2mxa6L1IPoEQRDEvc+9qSYaiBPNGT4dwaHIGY0mBbW1bq6XOr+kiHkLAEv6LcHyM8tV42eaj+B1lFUg3DO8xgM8qAuPIAiCIIi6hsSyA3krqfF0+b/V+y0s2L8AHYM6WizbPGYzIj0j0S20G7S8FiPWizFWe4f1Rv/I/vXd1L8Ey4cuR4GuoKGbQRAEQRBENSGx7CBu+1Rdpj6RUtOGeYrRGqa0moJvz3+LpJgkNPVqCgBo4duiwdr3V6Mm2bIIgiAIgmh4SCw7iK0JjcdHGQDaBrbFksQlcurcBV0XYEHXBaplP+r3Ef575r+qAfZnxs+Us9QRBEEQBEH81XCIWGaMzQXwLoBAQRCyVJZPA/D3ysnXBUFY5ojtNia2dm5YsfxGrzfkNMex/mIoNSnFZlX0i+yHfpH9VJfVRbaeqnip80uKDG4EQRAEQRANRa3FMmMsAsAgAGlWlvsB+AeABAACgGOMsY2CIOTWdtuEyJEpR+CmdUOUVxTKDeVWU/b+WZjaZmpDN4EgCIIgCAIA4Ahz6AcAXoQohNUYDGC7IAg5lQJ5O4AhDthug7N0qHj4rgfU/7bndJgDAFiSuETOXNc2sO2fXigTBEEQBEE0JmplWWaMjQZwUxCEk4xZDZUWBuC6yfSNynlq9T0O4HEAiIyMrE3T6oWzEQwvPcojw7vqstWljX8baDgNTmWeUl3+WNxjuM/nPtwfcb/jN04QBEEQBEEAsMOyzBjbwRg7rfI3GsDLAP7PUY0RBOELQRASBEFICAwMdFS11WLe4BgUZ9qXbOOWP8PVEIYiV8fEVE6MSAQAzO8yH98N/04O+zYpZhK6hXbD0QePymU1nAb9I/vDxkcKQRAEQRAEUUuqtCwLgjBAbT5jLB5AMwCSVTkcwHHGWBdBEG6bFL0JINFkOhzAnhq2t855ql8LnHuy/v0qVgxdgbaBbaEX9HJUiviAeADiALweTXrUe5sIgiAIgiD+6tTYDUMQhBQAQdI0YywVQIJKNIxfAbzJGPOtnB4EQD2G2V+U9aPWyzGPOWY09g+KGoTtgdsV6Y2/GvQVMkoy6r2NBEEQBEEQf0XqJM4yYywBwN8EQZghCEIOY2wRAMmHYKEgCDl1sd36ZGe72rk/2Jvi2VQoA0CX0C612i5BEARBEARhPw4Ty4IgRJn8TgYww2T6awBfO2pbjYFi55qvu3XsVsc1hCAIgiAIgqgzKIOfOTePVVlkRT8Ov3aqvmXZXmsyQRAEQRAE0TggsWxO5oUqi2zq1rhSWxMEQRAEQRB1A4llC2xbjB98gbe7pgOTDkDLaXEt/xo8nDxq2zCCIAiCIAiiniGxXE3Ktfa7X3g7i9lKWvu3rqvmEARBEARBEHUI+RNYYC1rN7CrLSUAIQiCIAiC+CtBYtkcfbn1RVUcraHNhjq4MQRBEARBEERDQmLZHBvpozN8bFuWF/dZ7OjWEARBEARBEA0IiWU7WZXIYWNXcsMgCIIgCIL4K0Fi2U42dOcgcNbF8geJHwCgWMoEQRAEQRD3EiSWzRAq9DVar4VPC/l3hGeEo5pDEARBEARBNCAUOs6MvEPnarRelHeU/Pv7kd+jqLzIQS0iCIIgCIIgGgoSy2YUpVy1mHfsPnX3C0+tJwrKCyzmu2vd4a51d3jbCIIgCIIgJMrLy3Hjxg2UlpY2dFP+NLi4uCA8PBxardbudUgsmyEU5FjMe3ecureKn6sfCsoL0NK3ZV03iyAIgiAIQsGNGzfg6emJqKgoMBvRvAgRQRCQnZ2NGzduoFmzZnavR2LZnLwbMHfl1vPqF2BieCJGtRiFEPeQemgYQRAEQRCEkdLSUhLK1YAxBn9/f2RmZlZrPRLL5lSUAXC1q+jchLl0gRIEQRAE0WCQDqkeNTleFA2jFtAFShAEQRAEcW9DYtmMilJeMX04hgQxQRAEQRBEYycnJwcDBw5EdHQ0Bg4ciNzcXIfUS2LZjJIsJ8X02t50iAiCIAiCIBxNRUWFQ+t7++230b9/f1y8eBH9+/fH22+/7ZB6yWe5hsT6xzZ0EwiCIAiCIAAA/9x0BmfT8x1aZ5smXvjHSOt6JzU1FUOGDEGnTp1w/PhxxMbGYvny5XBzc8PChQuxadMmlJSUoEePHli6dCkYY0hMTET79u1x4MABTJ48GS1btsTrr78OnU4Hf39/rFq1CsHBwXjttddw9epVXLlyBWlpafjggw9w+PBhbN26FWFhYdi0aZNF+LcNGzZgz549AIBp06YhMTER//rXv2p9HMhsWgUGK0coKSapfhtCEARBEATRyLhw4QJmzZqFc+fOwcvLC59++ikAYPbs2Th69ChOnz6NkpISbN68WV5Hp9MhOTkZc+fORa9evXD48GGcOHECkyZNwuLFi+Vyly9fxq5du7Bx40ZMnToV/fr1Q0pKClxdXfHzzz9btOXOnTsIDQ0FAISEhODOnTsO2UeyLFdBup/lvG3jtlG4OIIgCIIgGg22LMB1SUREBHr27AkAmDp1Kj766CO88MIL2L17NxYvXozi4mLk5OQgNjYWI0eOBAAkJRkNjjdu3EBSUhJu3boFnU6niH88dOhQaLVaxMfHQ6/XY8iQIQCA+Ph4pKam2mwXY8xhgRjIslwVKgc61COUImEQBEEQBPGXx1wPMcZQWlqKWbNmYd26dUhJScHMmTMVWQbd3Y1ZjufMmYPZs2cjJSUFS5cuVZRzdnYGAHAcB61WK2+L4zhVf+fg4GDcunULAHDr1i0EBQU5ZB9JLFeTlcNWNnQTCIIgCIIgGgVpaWk4dOgQAODbb79Fr169ZMEbEBCAwsJCrFu3zur6eXl5CAsLAwAsW7asVm0ZNWqUXMeyZcswevToWtUnQWK5GiTFJKFdYLuGbgZBEARBEESjICYmBp988glat26N3NxcPPnkk/Dx8cHMmTMRFxeHwYMHo3PnzlbXf+211zBhwgR06tQJAQEBtWrL/PnzsX37dkRHR2PHjh2YP39+reqTYIIgOKQiR5OQkCAkJyfX+3bPtWqtmJ64wOjWffTBo3DRuNR3kwiCIAiCICw4d+4cWrduXXXBOiI1NRUjRozA6dOnG6wNNUHtuDHGjgmCkKBWnizLdhLgGkBCmSAIgiAI4i8GiWUblJsk8/t13K8N1xCCIAiCIIhGRlRU1J/OqlwTSCzboLQy1nWHoA5w4p1sFyYIgiAIgiDuOUgs26C40uuiX0S/hm0IQRAEQRAE0SCQWLbBokmiH0bvsN4N3BKCIAiCIAiiISCxbIMMXzH4dQvfFg3cEoIgCIIgCKIhILFMEARBEARB/On5/vvvERsbC47j4MjwwySWCYIgCIIgiHpHLWV1bYiLi8OPP/6IPn36OLReTdVF/tpQxj6CIAiCIBo9W+cDt1McW2dIPDD0bauLU1NTMWTIEHTq1AnHjx9HbGwsli9fDjc3NyxcuBCbNm1CSUkJevTogaVLl4IxhsTERLRv3x4HDhzA5MmT0bJlS7z++uvQ6XTw9/fHqlWrEBwcjNdeew1Xr17FlStXkJaWhg8++ACHDx/G1q1bERYWhk2bNkGr1SraU1cJWsiyXAWvdnu1oZtAEARBEATRKLlw4QJmzZqFc+fOwcvLC59++ikAYPbs2Th69ChOnz6NkpISbN68WV5Hp9MhOTkZc+fORa9evXD48GGcOHECkyZNwuLFi+Vyly9fxq5du7Bx40ZMnToV/fr1Q0pKClxdXfHzzz/X2z6SZbkKtJy26kIEQRAEQRANiQ0LcF0SERGBnj17AgCmTp2Kjz76CC+88AJ2796NxYsXo7i4GDk5OYiNjcXIkSMBAElJSfL6N27cQFJSEm7dugWdTodmzZrJy4YOHQqtVov4+Hjo9XoMGTIEABAfH4/U1NR620eyLFdBiHtIQzeBIAiCIAiiUcIYs5guLS3FrFmzsG7dOqSkpGDmzJkoLS2Vy7i7u8u/58yZg9mzZyMlJQVLly5VlHN2dgYAcBwHrVYrb4vjOIf7O9vCIWKZMTaXMSYwxgKsLNczxn6v/NvoiG3WF25at4ZuAkEQBEEQRKMkLS0Nhw4dAgB8++236NWrlyx4AwICUFhYiHXr1lldPy8vD2FhYQCAZcuW1X2Da0CtxTJjLALAIABpNoqVCILQvvJvVG23WR+cimJVFyIIgiAIgvgLExMTg08++QStW7dGbm4unnzySfj4+GDmzJmIi4vD4MGD0blzZ6vrv/baa5gwYQI6deqEgABVm6vdrF+/HuHh4Th06BCGDx+OwYMH16o+CSYIQu0qYGwdgEUANgBIEAQhS6VMoSAIHtWpNyEhQXBkjDx7OddKHEm5tRPDN4N4pExz8MhSgiAIgiAIB3Du3Lk6iwBhD6mpqRgxYgROnz7dYG2oCWrHjTF2TBCEBLXytbIsM8ZGA7gpCMLJKoq6MMaSGWOHGWMP2Kjv8cpyyZmZmbVpWq1htfuGIAiCIAiCIO4BqoyGwRjbAUBtlNsrAF6G6IJRFU0FQbjJGGsOYBdjLEUQhMvmhQRB+ALAF4BoWbaj3jpDIC8MgiAIgiAIq0RFRf3prMo1oUqxLAjCALX5jLF4AM0AnKwcnRgO4DhjrIsgCLfN6rhZ+f8KY2wPgA4ALMQyQRAEQRAEQTQmauyGIQhCiiAIQYIgRAmCEAXgBoCO5kKZMebLGHOu/B0AoCeAs7Voc73ABMCZd27oZhAEQRAEQRANSJ3EWWaMJTDG/lM52RpAMmPsJIDdAN4WBKHxi2UAQ5sNbehmEARBEARBEA2IwzL4VVqXpd/JAGZU/j4IIN5R26kvMnwYXu78UkM3gyAIgiAIgmhAKIOfFUq1APf/7d1tbFTZfcfx798wiw0NeBdX3qztjb0SD8ZYEGyiLVgtJE0wKZS+CDJWrWyf/ALLqN2C2k3yxkUIaa1uaVGhcZW0gorHuqiLQSjs1khdVLzBa3Yz7hpnMZ4aR1BYnhKKnYnZ0xdzMAP4smCGmbH9+0hXvvfcc+85M38d++875841vT0iIiIiY8lbb72FmfHppw99m/GoKBt8hKzJWanugoiIiMi49CweWX3hwgWOHz/Oyy+/nLBzJmwaxniT4R5+3rmIiIhIOnrzx29y9trZhJ5z7gtz+cuvBE9JjUQiVFZWUlZWRkdHByUlJezevZupU6eyefNmWlpaGBgYYMmSJTQ1NWFmLFu2jIULF3Ly5Emqq6uZPXs2W7ZsIRqNMnPmTPbs2UNubi4NDQ309vZy/vx5+vr62LZtG21tbRw7doy8vDxaWloIhUIP9en111+nsbGRNWvWJOx90JXlAL/QRWURERGRR+ru7qauro6uri6mT5/Ozp07Aaivr+f06dN0dnYyMDDAkSNHho+JRqO0t7ezceNGKioqaGtr48yZM6xbt47Gxsbhej09PbS2tnL48GFqampYvnw54XCYrKwsjh49+lBf3n77bfLy8liwYEFCX6OuLD+gZtMkfivs+K9iXVUWERGRseFRV4CfpYKCApYuXQpATU0N27dvZ9OmTZw4cYLGxkZu377NtWvXKCkpYfXq1QBUVVUNH9/f309VVRUXL14kGo1SVFQ0vG/lypWEQiFKS0u5c+cOlZWVAJSWlhKJRO7rx+3bt9m6dSvHjx9P+GvUleUHREPGO4syQFMwRERERB7pwSmrZsbg4CB1dXU0NzcTDoepra1lcHBwuM60adOG1zds2EB9fT3hcJimpqb76k2ZEnveRUZGBqFQaLitjIyMh+Y79/T00Nvby4IFCygsLKS/v59FixZx6dJ9j/8YFSXLIiIiIjIqfX19nDp1CoC9e/dSUVExnPDm5ORw69YtmpubA4+/efMmeXl5AOzatWvU/SgtLeXy5ctEIhEikQj5+fl0dHTw4osvjvqcdylZFhEREZFRmTNnDjt27KC4uJjr16+zfv16srOzqa2tZf78+axYsYLFixcHHt/Q0MDatWspKysjJycniT1/fOacS3UfRlReXu7a29uT3m7prnvPTwm/Fk56+yIiIiKPo6uri+Li4pS1H4lEWLVqFZ2dnSnrw2iM9L6Z2QfOufKR6uvKsoiIiIhIACXLAQq+UJDqLoiIiIikrcLCwjF3VXk0lCwHKMstS3UXRERERCTFlCyLiIiIiARQshzgM/dZqrsgIiIiIimmZDlAun5LiIiIiIgkjx53HeAzdGVZREREZKyoqqqiu7sbgBs3bpCdnc2HH3741OdVshzgpWkvpboLIiIiIuPW0NAQkycnLhU9cODA8PrGjRuZMWNGQs6rZDlA4YzCVHdBRERE5LFc2rqVX3adTeg5pxTP5cXvfjdwfyQSobKykrKyMjo6OigpKWH37t1MnTqVzZs309LSwsDAAEuWLKGpqQkzY9myZSxcuJCTJ09SXV3N7Nmz2bJlC9FolJkzZ7Jnzx5yc3NpaGigt7eX8+fP09fXx7Zt22hra+PYsWPk5eXR0tJCKBQasV/OOQ4ePEhra2tC3gfNWQ5gWKq7ICIiIpLWuru7qauro6uri+nTp7Nz504A6uvrOX36NJ2dnQwMDHDkyJHhY6LRKO3t7WzcuJGKigra2to4c+YM69ato7GxcbheT08Pra2tHD58mJqaGpYvX044HCYrK4ujR48G9um9994jNzeXWbNmJeQ16spygFDGyP+tiIiIiKSbR10BfpYKCgpYunQpADU1NWzfvp1NmzZx4sQJGhsbuX37NteuXaOkpITVq1cDsbnFd/X391NVVcXFixeJRqMUFRUN71u5ciWhUIjS0lLu3LlDZWUlAKWlpUQikcA+7du3j+rq6oS9Rl1ZDvD1L3091V0QERERSWtm9tD24OAgdXV1NDc3Ew6Hqa2tZXBwcLjOtGnThtc3bNhAfX094XCYpqam++pNmTIFgIyMDEKh0HBbGRkZDA0NjdifoaEhDh06dF9C/rSULAeYlDEp1V0QERERSWt9fX2cOnUKgL1791JRUTGc8Obk5HDr1i2am5sDj7958yZ5eXkA7Nq166n78+677zJ37lzy8/Of+lx3KVkWERERkVGZM2cOO3bsoLi4mOvXr7N+/Xqys7Opra1l/vz5rFixgsWLFwce39DQwNq1aykrKyMnJ+ep+7N///6ETsEAsHR9+EZ5eblrb29PersfX/2Yj658RPXcxL7RIiIiIonU1dVFcXFxytqPRCKsWrWKzs7OlPVhNEZ638zsA+dc+Uj1dYPfA+bNnMe8mfNS3Q0RERERSQOahiEiIiIiT6ywsHDMXVUeDSXLIiIiImNUuk6nTVejeb+ULIuIiIiMQZmZmVy9elUJ82NyznH16lUyMzOf6DjNWRYREREZg/Lz8+nv7+fKlSup7sqYkZmZ+cRfK6dkWURERGQMCoVC9z3xTp4NTcMQEREREQmgZFlEREREJICSZRERERGRAGn7BD8zuwL8T4qazwE+TVHbkjyK8/inGE8MivPEoDhPDKmK85ecc78+0o60TZZTyczagx55KOOH4jz+KcYTg+I8MSjOE0M6xlnTMEREREREAihZFhEREREJoGR5ZP+Y6g5IUijO459iPDEozhOD4jwxpF2cNWdZRERERCSAriyLiIiIiARQsiwiIiIiEkDJchwzqzSzbjM7Z2ZvpLo/8vnMrMDMTpjZx2b232b2p778BTN7x8w+8T+f9+VmZtt9jH9iZovizvWar/+Jmb0WXZRARwAABHVJREFUV15mZmF/zHYzs+S/UjGzSWZ2xsyO+O0iM3vfx+WAmT3ny6f47XN+f2HcOb7jy7vNbEVcucZ+GjCzbDNrNrOzZtZlZr+hsTz+mNnr/vd1p5ntM7NMjeexz8z+ycwum1lnXNkzH79BbSSUc05LbN72JKAHeAV4DvgImJfqfmn53Lh9EVjk178A/BSYBzQCb/jyN4A3/fo3gWOAAa8C7/vyF4Dz/ufzfv15v+/Hvq75Y1em+nVPxAX4c2AvcMRvHwTW+fXvA+v9eh3wfb++Djjg1+f5cT0FKPLjfZLGfvoswC7gT/z6c0C2xvL4WoA8oBfI8tsHgT/QeB77C/CbwCKgM67smY/foDYSuejK8j1fAc45584756LAfmBNivskn8M5d9E51+HXfwF0EftlvIbYH178z9/z62uA3S6mDcg2sy8CK4B3nHPXnHPXgXeASr9vunOuzcVG4u64c0mSmFk+8DvAD/y2AV8Fmn2VB2N8N/bNwNd8/TXAfufcL51zvcA5YuNeYz8NmNkMYn9sfwjgnIs6526gsTweTQayzGwyMBW4iMbzmOec+0/g2gPFyRi/QW0kjJLle/KAC3Hb/b5Mxgj/8dyXgfeBXOfcRb/rEpDr14Pi/Kjy/hHKJbn+FvgL4DO/PRO44Zwb8tvxcRmOpd9/09d/0thLchUBV4B/9tNtfmBm09BYHleccz8D/hroI5Yk3wQ+QON5vErG+A1qI2GULMu4YGa/Bvwb8GfOuZ/H7/P/heo7EscoM1sFXHbOfZDqvsgzNZnYR7j/4Jz7MvB/xD5SHaaxPPb5+aRriP1z9BIwDahMaackKZIxfp9VG0qW7/kZUBC3ne/LJM2ZWYhYorzHOXfIF/+v/9gG//OyLw+K86PK80col+RZCvyumUWIfaT6VeDviH1sN9nXiY/LcCz9/hnAVZ489pJc/UC/c+59v91MLHnWWB5ffhvodc5dcc79CjhEbIxrPI9PyRi/QW0kjJLle04Ds/wduc8Ru5HgcIr7JJ/Dz137IdDlnPubuF2Hgbt30b4GvB1X/m1/J+6rwE3/8c2PgG+Y2fP+ysc3gB/5fT83s1d9W9+OO5ckgXPuO865fOdcIbFx2eqc+33gBPAtX+3BGN+N/bd8fefL1/m764uAWcRuGNHYTwPOuUvABTOb44u+BnyMxvJ40we8amZTfRzuxlnjeXxKxvgNaiNxEn3H4FheiN2d+VNid9J+L9X90fJYMasg9pHLT4AP/fJNYnPa/gP4BHgXeMHXN2CHj3EYKI871x8Ru0nkHPCHceXlQKc/5u/xT77UkpJ4L+Pet2G8QuyP4zngX4EpvjzTb5/z+1+JO/57Po7dxH0TgsZ+eizAQqDdj+d/J3Y3vMbyOFuAvwLO+lj8C7FvtNB4HuMLsI/YPPRfEfuk6I+TMX6D2kjkosddi4iIiIgE0DQMEREREZEASpZFRERERAIoWRYRERERCaBkWUREREQkgJJlEREREZEASpZFRERERAIoWRYRERERCfD/66VjTXa1BogAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 864x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_update_to_data_ratio(MLP3_parameters, MLP3_updates)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2e49a56",
   "metadata": {},
   "source": [
    "**Comment:** The nonlinearity forward activations plot shows stabilization between the `Linear` and `Tanh` layers as we go deeper in the layers. We get a good low saturation percentage of $\\boldsymbol{\\sim8\\%}$ (saturation is not $0$ or too high) with a small standard deviation range of $0.66 - 0.67$ across the entire network, which supports model homogeneity/stability once again.\n",
    "\n",
    "The gradient distribution is fairly reasonable. All the different layers have roughly the same distribution. Things are not shrinking or exploding, and appear stable.\n",
    "\n",
    "The weights gradients distribution look symmetric, and aligned for most of the layers. The gradient-to-data ratio seems to average around $2$E-$3$, which matches up approximately with the update ratio plots' black line at $-3$ from $\\log{10^{-3}}$. However, we might need to increase our learning rate since the update ratio changes from $-3$ to roughly $-4$ around iteration step of $75000$ which is below the black line. Upon further inspection, switching off the learning rate decay might fix this."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "110c95a3",
   "metadata": {},
   "source": [
    "**Comment:** We can view the loss across batches of 1000 and take the mean for every batch. The loss decreases as iterations increases which is good!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 260,
   "id": "cc6d1bbf",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      0/ 100000: 2.2093\n",
      "  10000/ 100000: 2.0916\n",
      "  20000/ 100000: 2.5582\n",
      "  30000/ 100000: 1.9778\n",
      "  40000/ 100000: 1.9828\n",
      "  50000/ 100000: 2.1729\n",
      "  60000/ 100000: 2.2504\n",
      "  70000/ 100000: 1.9624\n",
      "  80000/ 100000: 2.4519\n",
      "  90000/ 100000: 2.2894\n",
      "training loss: 2.1088192462921143\n"
     ]
    }
   ],
   "source": [
    "MLP3_no_lr_decay_vars = train_model_no_lr_decay(Xtr, Ytr, C, layers, parameters, max_steps = 100000, \n",
    "            batch_size = 32, learn_rate=0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 261,
   "id": "df705df3",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 261,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(MLP3_no_lr_decay_vars)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 262,
   "id": "3a0a8be1",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAssAAAEICAYAAACpnLlcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nOydd1wUx/vHPwOcFBUQFRFEsTewothjF1tsicbEFk1MNJr+TbBEiSHqz0RNTNGoidEYS2yxoMaGHQv2hoUiotilifT5/bG7x97d7hU4ivq8Xy9fcruzs7Nt5pmnDeOcgyAIgiAIgiAIQ2yKuwEEQRAEQRAEUVIhYZkgCIIgCIIgVCBhmSAIgiAIgiBUIGGZIAiCIAiCIFQgYZkgCIIgCIIgVCBhmSAIgiAIgiBUIGGZIIjnCsbYKMbY4eJuR35hjPkwxjhjzK6422IujLFLjLGOxd2OgsIYS2WM1SjudhAE8XxBwjJBEC8sjLFgxtjKAtbBGWO1rNUmC8/dkTEWX8Tn/JMxFiLfxjlvyDnfX5TtKCiMsf2MsXfk2zjnZTjn0cXVJoIgnk9IWCYIgnhJeJ602ZbAGLMt7jYQBPHiQsIyQRCFjr52Vq69lLSnjLHJjLGHjLFYxthbsrLlGWNbGGPJjLETAGrq1f0jY+yWuP8UY6y9uD0QwGQAQ0Tz+zlxuwtj7HfGWAJj7DZjLERN2GKMHRT/PCfWMUTc/i5j7AZj7LHYNk8j127LGPtevLZoAL319r/NGLvCGEthjEUzxt4Tt5cGsAOAp3juVMaYJ2OsJWMsnDGWKF7Dz4yxUirnllw+xjDG4gDsE7evY4zdZYwlMcYOMsYaitvHAngLwBfi+baK22MZY13Fv+0ZYz8wxu6I/35gjNmrnN+GMTaVMXaTMXafMbaCMeYi7tvBGJugV/4cY2yg+Hc9xthu8R5fZYwNlpX7kzG2kDG2nTH2FEAnvXq+BdAewM/idfwsbte+h2Idv4rtSGWMHWGMeYjX84QxFskYayqr05MxtoEx9oAxFsMY+1DtmRME8WJBwjJBECUBDwAVAHgBGAlgMWOsrrjvFwDpACoDGC3+k3MSQBMAbgBWAVjHGHPgnO8EMBPAWtH83lgs/yeAbAC1ADQF0B3AO1CAc95B/LOxWMdaxlhnALMADBbbdBPAGiPX9i6APuK5/AG8prf/vrjfGcDbAOYzxppxzp8C6AngjnjuMpzzOwByAHwi3q/WALoAGG/k/ADwCoD6AHqIv3cAqA3AHcBpAH+L17tY/HuOeL6+CnVNAdAKwj1vDKAlgKkq5x0l/usEoAaAMgB+FvetBjBUKsgYawCgGoBQcaKwG8LzdAfwBoBfxTISbwL4FkBZADo+7JzzKQAOAZggXoeOUC5jsNj2CgAyAISL96MCgPUA5oltswGwFcA5CO9oFwAfM8Z6KNRJEMQLBgnLBEGUFL7inGdwzg8ACAUwWNT4DgIwjXP+lHN+EcBy+UGc85Wc80ec82zO+VwA9gDqGtQOgDFWCUAvAB+L9d0HMB+CMGYubwH4g3N+mnOeAWASgNaMMR+V8oMB/MA5v8U5fwxB0Ja3P5RzHsUFDgDYBUErqgjn/BTn/Jh4vbEAfoMgDBsjWLzeZ2Idf3DOU8T2BwNoLGl8zeAtADM45/c55w8AfA1guJGy8zjn0ZzzVAj36g0muINsAtCEMVZNVnaj2KY+AGI558vE6zwDYAOA12V1b+acH+Gc53LO081suz6bxPuZLrYnnXO+gnOeA2AthAkOALQAUJFzPoNznin6PS+BZe8NQRDPKSQsEwRREngialIlbgLwBFARgB2AW3r7tDDGPhfdGJIYY4kAXCBoBpWoBkADIEF0Y0iEIGy6i3Vdkrk8qAmsnvI2iELgIwBejLH2suMvycoba39Pxtgx0d0gEYIwr9Z+MMbqMMa2iW4UyRC056rlRbTnF91CZjPGosTjY8VdpuqQ0Ll+5D0rc8vaAajEOU+BMCmSBM6hEDXcEJ5TgPSMxPvyFgQLhME1FYB7sr+fKfwuI2uPp157JgOoZIU2EARRwnkhgz0IgihxpAFwkv32ACDP8lCOMVZaJjBXBXARwAMILhPeACJl+wAAokD7BQSz+CXOeS5j7AkAJhbheu24BcHcXoFznq3fSM55QzOu5Q4E4UlqQ2kA5QHcFjW9ZfTKJ4jtl5C33x6CxnQEBE1pFmPsXyPtB4CFAM4AGMo5T2GMfQxD1w595PW8CaAfgK4QBGUXAMbumT7S9UuTgariNmNlISubjTyhdDWA6UzwDXcAECZuvwXgAOe8m5F2mGqnqf2WcAtADOe8thXrJAjiOYE0ywRBFAVnAbwpajUDoew28DVjrJQoAPcBsE40h28EEMwYcxJ9VkfKjikLQfh6AMCOMTYNgu+vxD0APqLPKTjnCRDcHOYyxpzFALSajDFjbgz3IPjbSqwG8DZjrIko7M4EcFwUlJX4B8CHjLEqjLFyAIJk+0pBcBt5ACCbMdYTgg+1/Nzl9VwkygJIBpDKGKsHYJyRtitRFsKE4RGECcxMvf3616vPagBTGWMVGWMVAEwDoJaebzWATxhj1RljZZDnQy5NVLZDEKZniNtzxe3bANRhjA1njGnEfy0YY/UtuE5T12EJJwCkMMa+ZIw5iu+xL2OshZXqJwiiBEPCMkEQRcFHAPoCkMzp/+rtvwtBu3kHgin+fc65pEmeAEFbexdCcN4y2XH/AdgJ4BoEE386dM3z68T/HzHGTot/j4AgpF4Wz7keQqCeGsEAlovm98Gc8z0AvoKgEU6AkJ3DmO/qErGd5yAEj22UdoiuCB9CEKifQND6bpHtj4QgcEaL5/cE8LlYLkWse62RcyuxAsK9ug3hHhzT2/87gAbi+fSfEwCEAIgAcB7ABfGaQhTKAcAfAP4CcBBADITnM1F2fRkQ7kdXCMF80vYUCJOGNyC8E3cB/B+EiYW5/AjgNTGzxQILjjNAnLT1gRDUGAPgIYClELTyBEG84DDOrWmpIgiCsAwmrAy3knNepbjbQhAEQRD6kGaZIAiCIAiCIFQgYZkgCIIgCIIgVCA3DIIgCIIgCIJQgTTLBEEQBEEQBKFCic6zXKFCBe7j41PczSAIgiAIgiBeYE6dOvWQc15RaV+BhGXG2HcQ0kFlAogC8DbnPFGhnCuENDu+EBLFj+ach5uq38fHBxEREQVpIkEQBEEQBEEYhTF2U21fQd0wdgPw5Zw3gpDndJJKuR8B7OSc1wPQGMCVAp6XIAiCIAiCIAqdAgnLnPNdspWYjgEwyJMqrjzVAUKie3DOM5W0zwRBEARBEARR0rBmgN9oADsUtleHsJTrMsbYGcbYUsZYabVKGGNjGWMRjLGIBw8eWLF5BEEQBEEQBGEZJn2WGWN7AHgo7JrCOd8slpkCIBvCMrVK52gGYCLn/Dhj7EcAQRCWizWAc74YwGIA8Pf3p7x2BEEQBEEQCmRlZSE+Ph7p6enF3ZTnBgcHB1SpUgUajcbsY0wKy5zzrsb2M8ZGAegDoAtXTtocDyCec35c/L0egrBMEARBEARB5JP4+HiULVsWPj4+YIwVd3NKPJxzPHr0CPHx8ahevbrZxxXIDYMxFgjgCwCvcs7TVBp2F8AtxlhdcVMXAJcLcl6CIAiCIIiXnfT0dJQvX54EZTNhjKF8+fIWa+IL6rP8M4CyAHYzxs4yxhaJjfFkjG2XlZsI4G/G2HkATQDMLOB5CYIgCIIgXnpIULaM/NyvAuVZ5pzXUtl+B0Av2e+zAPwLci6CIAiCKCqu3UtBYloWWlZ3K+6mEARRzNBy1wRBEAShR/f5BzH4N5NrZxEEUYJ4/PgxunXrhtq1a6Nbt2548uSJVeolYZkgCIIgCIIocrKzs00XsoDZs2ejS5cuuH79Orp06YLZs2dbpV4SlgmCIAiCIAiLiY2NRb169fDWW2+hfv36eO2115CWJuR7mDFjBlq0aAFfX1+MHTsWUsK0jh074uOPP4a/vz9+/PFHbN26FQEBAWjatCm6du2Ke/fuAQCCg4MxcuRItG/fHtWqVcPGjRvxxRdfwM/PD4GBgcjKyjJoz+bNmzFy5EgAwMiRI/Hvv/9a5ToL5LNMqBN5NxlPnmahdc3yxd0UgiAIgiBecL7eegmX7yRbtc4Gns6Y3reh0TJXr17F77//jrZt22L06NH49ddf8fnnn2PChAmYNm0aAGD48OHYtm0b+vbtCwDIzMxEREQEAODJkyc4duwYGGNYunQp5syZg7lz5wIAoqKiEBYWhsuXL6N169bYsGED5syZgwEDBiA0NBT9+/fXacu9e/dQuXJlAICHh4dW8C4opFkuJAJ/OIShS44VdzMIgiAIgiAKDW9vb7Rt2xYAMGzYMBw+fBgAEBYWhoCAAPj5+WHfvn24dOmS9pghQ4Zo/46Pj0ePHj3g5+eH7777Tqdcz549odFo4Ofnh5ycHAQGBgIA/Pz8EBsba7RdjDGrZQohzTJBEM8VnHN8sOo03gqohra1KhR3cwiCIEoEpjTAhYW+QMoYQ3p6OsaPH4+IiAh4e3sjODhYJ7dx6dKltX9PnDgRn376KV599VXs378fwcHB2n329vYAABsbG2g0Gu25bGxsFP2dK1WqhISEBFSuXBkJCQlwd3e3yjWSZpkgXnJycjmUF98smWTm5GL7hbt4e9nJ4m7KS8vlO8k4fP1hcTeDIIgSQFxcHMLDhcwxq1atQrt27bSCcYUKFZCamor169erHp+UlAQvLy8AwPLlywvUlldffVVbx/Lly9GvX78C1SdBwjJBvOTUnLwdE1efKe5mEM8RvRYcwrDfjxd3MwjC6ry97ASmbb5Y3M14rqhbty5++eUX1K9fH0+ePMG4cePg6uqKd999F76+vujRowdatGihenxwcDBef/11NG/eHBUqFMxaGBQUhN27d6N27drYs2cPgoKCClSfBLlhEASBbecT8PObxd0KgiCI4iXs6gMAwIx+vsXckucHOzs7rFy50mB7SEgIQkJCDLbv379f53e/fv0UNcBydwwASE1NVd0nUb58eezdu9d0oy2ENMvPCfuv3sfXWy+ZLkgQJYjlR2PR/5cjVq1T8hjJzMm1ar1E4cE5R06uoatPbi5HeNSjYmjR801mdi6uJFg36wFBEOqQsPycMGrZSSw7ElvczSBkZOXk4rcDUcjMJqFNzomYx9gXKaTrmb7lEs7eSizmFhHFzS9hN1Bz8nakpOvmRV18KBpDlxzDgWsPiqllhly8nYT0rJziboZRpm+5hJ4/HsKdxGfF3RTiJcfHxwcXL774biskLD9nzNpxBZ+sPVvczSAArAi/iVk7IvH74ZgiPW9Gdg7uJ6ebLmiEwgzqG/xbOEb/GVEodQPAg5SMQqu7sMnKyX2ugimtxZqTtwAAiWm6wvKN+4JZ9V5Swd5na/H4aSb6/HQYn607Z7U6d15MgE9QKOKfpFmtztM3hSV8k9MNF2UgCML6kLD8nPHbgWhsOnO7wPUsPhiFkX+csEKLDNlz+R7G/31K+zsnl+P2C6gBeZohpK1Jy7Tucp2m+ODv02g5U90nKy0zGyHbLqtqx7JzclFz8nZ89o/1BIKipP2cMNV92Tm5JVaYfpqRjdpTdmD+nuvF3ZSSh3VSoQIQ3v/8Lswgfctn4/JvDRn950nUmrxd+3v9KaG/tvZiEQSRHzKzc/EkLbO4m/HcQcJyCSM7JxcZ2YVvApy5PVJr+rwQn4RePx6ymtD3zooIbL9wV/t7/u5raDt7n9kCc3pWDubsjMSzTMvvQ0Z2jlXcIs7EPYFPUKhZA1xRKwr3XLlvdH+Daf9h6eEYVbedbNF3dKMVJl0ljan/XkSLb/fk690pbJKeCVrAdRG3irklJYf8fDucc8zZGYlbj5U1tRNWnUGvBfnrz6zxLe+LvK/9xoQ6hb//u2SdlcT0WXYkBkdvlMw0fqduPjFwvbE2nHMkJL14yhhrkJ2Ti8i7yTqKk5iHqbj1OA25CjEE2bm5SH5m/eeVnpWDrOc8xoSEZROsi7iFrefuFNn5Bi0KR92pO61a563HafAJCsXF20mK+7/dfhmXE5IxYdWZQjERH7ouCOXmavxWhMfi1/1R+O1glMXnqjt1Jzp9v9/i4/TZeUkQ9o35UhZEGdZ9/gEsOxKDpGdZmLb5YqH4SObkPt+dkzn8diAK83Zd1f7efiEBACyecD5MzcCmM/FWbZs+L5/zhflY8i1dv5+KX/dH4f2VpxT3n4x9DADIyikZdzxDnLxvOG3++8U5xz0FV6tbj9MMJglfb72MN5eaTuOXlZOLX/ffKDJ/7GeZORi08CjGrlB+TtZizclbaD1rH85RbIQBKenZyMzWtbYZ+y7iHqUh9tFTqwu21+6lIDIhBQBwPj4Rd5/DyQ0Jyyb43/rzmLj6jKKgd/lOslVmzQ9SMrQdYGF88GFXBU3k2pPGNVr7Iu8jPOoRbj1Ow+J8CKrWYub2SADIt4a4qF0+Dt94CJ+gUNxPyRvcHqVm4GGq+uTg2r1UfL31MubvvoYV4Tex7lThCmr5IepBqlYbWlKZtSMSC/bdMNjOLJzKjF0RgU/WnlMUUEoa6Vk5ePXnwzqBk1vP3cGey4WjucwPn/5z1iwlA8/HFCJXnNBnqw36JUNG1pKf1XaXHopBwMy9Wp/uDaficSLmMdrPCUP7OWH5um9rTsRhzs6rGPxbeJH4zWeJk3U1JY21OBEjTI6iHqSaKFky4ZxjycFoPHlqPdcIzjliHz7FUwutK9KYq/R+pGVkF8hHXv7O3i9EV7l169ahYcOGsLGxQUSE9WJnSFg2k6FLjhls67XgEEbJVhGb+u8F+ASFWlx3i2/3KPphxj9JQ9wj84NCEpKeYe3JONX9F+8kmewkM3NyMWrZCczcHmk1wSG/3fL+q0UbIZ+elYNVx+N07pGxQSld1F5KQsu5W3mDQvOQPfAP2aNT/uC1B5i1/YrOrP3mo6fCeUpg0FeXuQcU0771+ekQ/j5+06K6/om4pTOZKCy0d9FCAeWuGGCmpFFJSstC3KM0HLr+QDH9mTlcvpOMv8KFe5aQlJ7vegBB+Dgfn4Rvtl3Wbpu4+gzeWVF4QZVqbFCZ5G08fVtxoRvOgY/XnNFO4KUHpr9cbkGQ7qypKndevIs1J9T7SzUepGTk6zhA6CsSZf6io/88ibeXGcaOHBStcVJQ4GfrzmHwb+EG5SyZFKaJrknn45MKzSWkOCiqvnPpoWhcvZti8XFn4p4YdZOJuPkE326/gqCN5wvSPB2ycziS07Pw2IoC+I0HqYh9+NRq9QGCm8izjEykZ+VYzV3H19cXGzduRIcOHaxSnwQtSmImklCjzykxKhkAVh7LXweqRrv/EwTo2Nm9zSo/8o8TuHYvFU2rlkOdSmUN9p+JS8SyI7EY3a66dpu+9pYxhqcZQqdakAEdAMIi76NTvbx12U1163cSn+m4PVwu4jyi83Zfw+KD0XArrTE5CN1JfIZfwizTvo8QAyrt7fLmqGEWTgiUfHH/PXMbHBwDmlYx2Hc/OR2P0zJRz8NZu80SuSRGoXO8eDsZUzZdxFsB1cyu54v159Goigu2TGhnsC8h6Rmyczi83ZyM1pGVkwuNrfH5PdcKX2Y3TTgO0nF5B8Y9SoO7sz2ahezWfguVnO1xfHJXk/UFb7mEP4/Gar/dXgsO6ew/HvMIbWrmb6WqZxaa0bPFCYCdiXtnjM/XncOpm08Q9nlHne27Lt/FoOaG750+8ufx79k7+PfsHYR93hG7rwhCmyWPK2jDBaP7U8XAW1N1Sm4cb7Ssqt0mvT/GrFNj/4rAmbhEtK9TEV6ujthxIQEJSek6/aoa/X85ggaVnbH9o/YABGueMUxNItQm85nZuYh7nIZa7mUU9xuzehkjOT0LZe3tFNuVkZ0Deztbk3VIvuROpawrflhxvgVAcHmR90khoVdgaxOJqJm9DMo+y8zB7cQ01HI3HHcH/HoUgPo4Lo3BKemFFyjOVf42VT49KwelbG1gY6N+c2NjYxEYGIjmzZvj9OnTaNiwIVasWAEnJyfMmDEDW7duxZPkVDTxD8C6lcsAAGNe74O2Af7Yve8AAvsNQrUaNbFkwVzwnCy4uZXHurWrUalSJQQHByMmJgbR0dGIi4vD/PnzcezYMezYsQNeXl7YunUrNBqNTnvq169v2c0xE9Ism4kl/m//yAJ49l813hnmlzNxTwy2SaaN1xYeVT0u8q6uAKrv36uv+SwIli6iMmzpcUzaqDsQ9vnpEN7/q/B83h6mZuDD1Wew5dwdPEoVZuHyTmvruQRcu2eoTYhTCC5S6k7SMrO1ZkKJB/kcqACg/Zx92r8l38OP157FJ2uFzBb66anazQlD4A+6glpx8TAlAyuP3dTxMQaA1rP26VhW4p+kGaTjO3z9IWpP2YHTCu+9EpaMm0KAkKBZ/vNIDHyCQpGTy9HhuzC8v/KUzqTxXrJ5z+7Po7HaupXbZ7qF5+MTFfPoSsLi7SfmuRs1mP6fduJtjGgjbjfrT8VrJ04hMo22dB33U9IRsu0yfIJCcTzavEVGOn2/P18Cgrl5u/UFuuVHY9Fkxi6Lz6eP5JKXk8NxIuYxxv19GjNk90ROaka2QX9qSgnwKDUD0Q+Ee73r0l1FH2NT78+0zRfRdd4BbVufPM3U+vMD6oJlWOR9dJm7X3EMuJecjkbBu7DoQLTBviM3HqLu1J0GfZ0SDab9h4bT/zNZzlwsVelE3k3GpTumXUOUrL1qCqS3/zyBrvMOFn9+7h1ByPmjF2xX9EGNbUO0/9w3DARf1gvZv/dE9W2DUWPbELDlvYFlvZH7Ry/wZb2AZb1RdcvrqLFtCDQr+orleyF1y+cmT3v16lWMHz8eV65cgbOzM3799VcAwIQJE3Dy5Els3BuO9PRn2LZtm/aYjIwMrN4ehpHvTUCzFq2xcsturNp+AJ1798ecOXO05aKiorBv3z5s2bIFw4YNQ6dOnXDhwgU4OjoiNNRyS35+IWFZgQmrThdIyP1ifZ45Re6mAQid1iNRWNpxIUHVbcNULmVptiqRnZOrzWGanJ6N+ynpqDN1B+btvmZwrDxKXF+DEnk3BY9E042lndD5+ESdzjL2URoW7o8yW9sXraLFlILtJO4mpZvdKUU9SMU50fQ5Z2ekVssmMfDXo9hy7g4+XH0GsTLrgdTWKwnJ6D7/IELPC89KzcKgxidrz2Lwb+F6eZENb4SaJfFKQjJ8gkKx8+JdZGbn4mFqnlnt8HVD015ErK4wqeSDJh9o5c8/OT0L1xUmBmtOxCF4yyX0++UITt00HAyzcnLhExSKt5edMPpcOIRsFUo+xoCwmtvZW4kY/vsJfLPtsk6cgGSWPmliMJau0xKzfqhMiFhySBDSJWFByRVo05l4dJm7H0sP5QkNmdm52K3gM7zkkKFgAQhuXabiE179+QjazN5nsF16ZlLqQn0S0zJ1hIHM7Fzc1XOpCou8j67zDugIRZ3nHkDjr3dh+mbdBQYiYnXv+VLZRGbnpbuYvvkihi89od0uPSsljkYpm6PzoxW8ei8F6Vk5Wk0yAKPuEdO3XDLI8wwIwukW0b9681nzM8QwBqw/pR4H8v1/V+E7/T8cizYtQMrp+P1+7TP++3gcvt6qLIgb47j4nQRvvYSp/15A029241y8aQFx8qYLiHrwFOFRjwwmetLETb8/BoS4DSAvuFKOUtcmVZ2SnoUlB6PhExRq0Pf4BIXi21Dzr/3SbcNJSNyjNAPFUuAPh9B7wWGz6zXF3iv3tM84u4DW2ILCwfEsM0fR+pSelYv0rFydB5KakY20zBxtEKpOXWK57GzT1+Tt7Y22bdsCAIYNG4bDh4X7GxYWhoCAAAzq2gYnjhzCpUt5CrSe/QZq/76XcBvvvzUIg7q2wZ+LftIt17MnNBoN/Pz8kJOTg8DAQACAn58fYmNjTbbNWpAbhgLbzidg2/kEzH29sc72qAep6DL3ADZ/0BaNvV2120PPJ6B3o8pG65y366qOkNC/iSf+PaseACPPpawv4Ek0mbEL4zvWxNgONTF7R6TOvpbfCnl4F+y9juC+DbTbORdm9nLUkibcuJ+KsSsisHpsKzg76Jo6OOdYdSIOP++7gW/6+aJrg0p49WdD/9b/2xmJ+pUFFwAlbcipm49xPj7J5ICQnZMLxhhsbRhazdqL1jXKY1Kvejgfn4S3AqoaCEfhUY9QvkwpdJ9/EAAwqFkVbDgdj7Unb+HUV93wV3gsOtZ119EQy11q9JGClS7fSUa18qUVyygN+FfECGB557XayIA+aOFRnLr5BOemd4eLowY9fxS0whtPx+ODVad1yioOQipTnDUnb2GozNwssfhAnitJo2BB6+bn5YKtE/PcJYJk2v5BCw39JiUBOezqA0zbnP+VnJYdjdXxw9XxHRf/Ts9St3psOhOPp6KbCoMgfM/acQUjWvvA2VGDwYvC8dObTVGprANG/HEcC4Y2RbXypRU1tMbcICUtfkjoFfTyqwxPV0fM230Niw5E4e93AtC2Vp57xaHrDzG2Q03Fer7fdRXL326J3w/HYGhAVZSxt8PeK/fQrnYFs8zZADB08TGDtFmvLwrH9fupiJ3dGwdVsrlM3nQBCUnpeJCSAU9XR519y8NvYlTb6qheQXjPX1uU98yV0rEtD7+JsvbmDSW3VBbmWHPyFgY2y3PniH+Shu//u4r/e62R0XtR7yshc5Bk4p4rUw6YK3+/v/IUTsY+wbqIWzikMAHVx1wXWWPZfMb8eVJVQ66vbVdazMRUgF+22KmHnk9Q3G9KMz3ijxMo62CHC8E9tNsk/9dztxLhExSqvecJSc+wcL/htZpz/8csj9AqWPZG3oe3mxMcNHnPe8mhGEzp3QDpWTmIfvAUDTyd8c/JW6jjURZNvF0xa8cVbBbH0aWHYzCsVTX4iO9telYOOnwnaIfHdayJIf7e2sVxJJ5mZOPG/VSd8VyOT1AoznzVDX1/1hWub9xPxRfrz2HFmAAclS3XXhD/6YK6XnPOkdopRNF1ztWpFJ7qWTlcHDVaS5KtDUNDTxfE3U1GZnYu6nqUBQND9N1kaGxt4CarK5dz2OgNdvrjL2MM6enpGD9+PCGa2SwAACAASURBVPYcPAJeugIWzpuN9PS8SbuNJq/fmT3tSwx/dzw6du+Fk+GH8dcv32v32dvbC+VtbKDRaLTnsrGxQXZ20a1xQJplI+iv4tRl7gEAQD+9oCd9IUaJhQd0OxMlQTlExZR3XEWblpiWpc0ccdKIoBcpC0pQyrpwQkEbAAAfrj6DS3eS8d9FQ03CkRuPMGXTRSQkpWPqv8YFpCui2fFI1EPcuJ8Cn6BQbYDYoIXhZmlOak3Zgc5z92t/h0c/wqs/H8HUfy8iPMrQ7Dt0yTGtoAzkBeM9epqJGVsv46vNl/DmUsOgTQm1jv6JqJlS29/v58P5CvKUkAT2NxYbtk3fBKhvos/IztFxY5FrOcKjHmHnxQSkZ+XoCPXLww0D9S7cTsLkTcb9QgFoM7j8dSyvDmlyABgGy8m1evruQAAMNEtK2o75ewwtJdp9u/MW+2BMCGhdcigGH645g4X7o3D1Xgp+2HMNOy8l4Fx8En4Ju6Etq4+52QYkzW/cY2GAUkr2v/eKcjBVSno2xv99Gt9uvwLf6f/hy/XnMWZ5BP5vx1UdrbUaHMJ3ECsLAj4e/QjX7+dlBZBr5xfsvY5Z26/g533XtW4nahklJPes8/G6Ap3+RFsJNQHNGJLA5BMUii/Wn8NX/17Ev2fvoEXIHu39y83l+HiNYdCgHH2BQymXLKD7bt5JFO6FOYKycA6hzhF/nMA/Ebr9qTwDiDHXvb2R97UWPABYdVx9Am2sXWpCrynBa/KmC+gi60+VSEnPRnZOLlrN3AufoFDFce5+cjpazzK0fphDdk6ujiVy9o5INP5a2U3ms3/OodeCQ5i3+xq+2HBeG3j8m55LSMfv92vd5tbLxrqF+6PQ8fv9WKQ3Dk9YdRr9fjliNLgs7nEa4mUT6szsXMzZGYnTcYlYpRfozCG8c3+FxyI9K0cnqHnnxQRFy6T0BMNF96WkZ1k6GvrHTzO179x3/0Wqji8PUjIUBWX980jkNybp4u0kXLqTpHN8XFwcwsOFSfWqVavQrl07rWDsUq4C0p6mYnfoZtU6U1KS4e7hCQDYsm51vtpV2JCwnE+skctXn6UqyyZvMzH4BP5w0KhJN7+BD9Ks87v/rhrs09eamDOjnr0jEl3nCQLssiOxZgkEcm4+StOmUpJjacDTH0eE+5ykYJIFhIFml0oarsmbLmD50VhFUYoxGJg6JaHLVFSyfmT+FT2/RqUJzfQtuj7hwVsu6Whef5CtFLfl3B28v/I0Qsw0axobvCXazwnD46eZmLMz7/24IEsTVXvKDp3y8uc0etlJg3dGXzvRfk4YVoTHwico1GTMQEp6lo6VgIFB6svPxCVqB0nO8wSJfyLi8Vd4LE7EGE40s8wwPSqhJLysi1DOGHH2VqKOSXutGOuwN/IeQkKvaLc/TM3A3aR0AxeYVAU3jCGySVbSsywdrfO83dfw28FofL8rb8LxlRFLAOdc0VqkhPzZyoV3zjmaztiFW4/NT+f4T0S81jc8OT0bY5YLWT7WRtwyao1Ly8zWCVxrNWsvashW0pOjppgwB+nNUBJMlDKAmIM0OVXrk/S5dk/oB+XCWsi2y9o+Vend0CfqgWH79b+z0AsJWhceJauO3C0MyBtr4p+kaQXa1IxspGflYMKq05gri1foOu+AQX3SBDlMFvjoExSqdZVasDevT1ObCHWffxDn4xNNrnR76U4Szojj5txd1+ATFKroRhb9UHfMmbTxgtZNZub2SJ2JCefAtgsJ+GrzJYz444TWwgsA7688jW7zZAqcrBxFV6oucw/g9UXhSM/Kwa/7b6DZN7u1GnFjQeVKygVjyN8RtXgbNXJyuU5ygLp16+KXX35B/fr18eTJE4wbNw6urq5499130SGgGcYNG4SGjZup1jfukyB8Pm4U3ujVEeXc3FTLmcOmTZtQpUoVhIeHo3fv3ujRo4fpg8ygQG4YjLHvAPQFkAkgCsDbnHMDqY0x9gmAdyD0MxfEciU/oakRjM3g9Jm362qBEuQbM9sDuppjJcIiC5aC7X5KBtIys3ElIRnNq7nh4u0kHW3H3eR0VJ+kPCipEf8kTUcgMJeVxww1oeag1BkkqwQXbTpz20Aolws107dcQo0Khq4Y+sGJQJ42daCRoEtA0CqEGwmMUvK11Gf1CdMrw5kbFGYua4ykKjTGnaR0/Hk0Ft0aVNJuUwpanbZZmBBIAXNq6E9eGRPyguqjP6f7arNyEOrc3YYTRGMY88u3NCfuTb10kfIUhCvHBJhdj5qWTs6Baw9wPzkd7s4OBvvUVoBUQs1Xc8hvx7TWGFPItb36QXB/HokxOuEc/vtxVCxjr7NNcmdYeigaPRp66OyT+xGbUibk5nL8uPc6Xm3iqbUuKqHkLmEpnUxoe/WRW4YkZUt++lVAcInTz5Lx0Rr12JlLd5IMfH+lyeJvB6J1hPEHKRkGSp9YlbSoEbGP8fafJxX3yckxoqAxZ5LXe8FhuDgK7oUrwmMBQBtYKUdyu5I4GvVQe5w+nHOtAKwU7JiZk4vQ8wkIqOGGzt/vR3J6Nla9E6BzvPQM/gq/qVVEHLr+QNGNDhCE7rtJz0xOkDKNBO5n53LdyQdXDmJXw87ODitXrtT+zsnlSM3IRkhICD743xSthatRFVecj0/E7+u2wdlBo83b3KlHL3TqkZdlxEd0dQwODtY5T2pq3risv09iwIABGDBggNltN5eC+izvBjCJc57NGPs/AJMAfCkvwBjzAvAhgAac82eMsX8AvAHgzwKeu0ShtvQqANWApqJCP7gnP0jm1/8+7oA+PxU8OMKY76kxlIQmSfM0srV6KjNT2nk598zIB6wUjKiUKUEasPPjj1YYS7iGXX2Qr1yhasi1ypby9dbLOi44piZ9xtDXcAFQXNVs56W7aFndtObCksnw0aiH2CG6KoVsu6x175CwZhrY24kFF8j0aTlzr2JaK3MyG5hC3yJibKGh3w6oa82CTbhqGXNVCAm9YlSAVNNQSoz7+xT+u3QPP8q0mkoMM2MVPWPsv3rfqnlxLeFZZg4++NsyrbhSkBxjpu+nKeQ+8saYszPSdCETSNYtqcn6KR6VSEhK17oxAXmWSqE+077aH6w6jcouDlplzTZZgLFc6fTtdvV3NvJuMpLSshB29QGau2TC1sQiH+kKKUf1UZMTsnJyFd/LJ2mZcCzlaLA9NT1bq42v61EW8tdB/m4YW+DkWVYOnFUmJMVFgYRlzrlcdXEMwGtGzuPIGMsC4ASg6NaPLiKU0sy8iCj5ZJYUlPxv88PDQlxdyBJM5WDNL9aY7DzPzFfIEFMQ3lySJyTdSUrHnSTdQcea8fFfmsgxnF/0fZMB5awHBUXKNqKE3D2kMDl18wmuyvzj9Z+XPuYu4KGmKTWX4lg9UvJ/9fVytopSJfbhU9SYvB0V9LT85sRAWIqxd8lcrJ27ggOKq/3qIxe2zXF5237hro7l4qt/L+KkmPloyavGkwsAeTE7xniYmgE7G2XPXCWrycPUDFQoYw8fHx9cvCi4cz15mqkTxKuvmLHUZbIkYU2f5dEAduhv5JzfBvA9gDgACQCS9IRsHRhjYxljEYyxiAcPinYFN0A58IjIowQuNGd11Nwzipof9xjXZAHGLRovM75G8rimmOHPaW6wlyluJz5TTClX0jDXN/lFYJAJl6iXkYsKadfyg+Rbq+/OYa3vydpYeyGQS3eSdDKyWBN5rvSTseblm7eUbLXUWCroy0uPTFhGcs0UIEqinGFSWGaM7WGMXVT4109WZgqAbAB/KxxfDkA/ANUBeAIozRgbpnY+zvlizrk/59y/YsWK+bmmArFIIQUOkYfSst9E4XDfDA1F4A8HTZZ5GSnufKcSSj6QBKGElNmIeH4Z/rvh0uXPI4kqixOZwlSGDXPd2+6b4QpZ1Jh0w+CcG13blTE2CkAfAF24ckqErgBiOOcPxPIbAbQBsFKhbLFjrsmNIEoCT83wRSMIouSjtnoiQRQ1lrgEnY9PhFvpUsXmb19UFMgNgzEWCOALAK9yztXswXEAWjHGnJiQG6oLgPyF6xYBz7NPDUEQBEEQRFHyogvKQMF9ln8GUBbAbsbYWcbYIgBgjHkyxrYDAOf8OID1AE5DSBtnA2BxAc9LEARBEARBEAbMnTsXjDE8fGgdf/mCZsOopbL9DoBest/TAUwvyLkIgiAIgiCIF4fs7GzY2RU0i7Eut27dwq5du1C1qnJu6vxg3RYSBEEQBEEQLwW3b8Vh/PDX0MCvMa5cPI+adeoh5IeFcHR0wqIf5uDg7p1IT3+GJv4B+Gr2fDDGMOb1Pqjb0A9nThxDYL9BqFajJpYsmIusrEy4lnPDrAWLgSquCA4ORkxMDKKjoxEXF4f58+fj2LFj2LFjB7y8vLB161ZoNIb5mD/55BPMmTMH/fr1U2hx/iBhmSAIgiAI4jnnr2sLcDPFdMpRS6hWtjaG1/nQaJnYqOsI/m4BmrZohWmfTcA/y3/HyPcnYujId/H+x18AACZ/9B4O7NmJjt16AgCyMjOxeruQDi85MRErt+wGYwwbV6/AsoUL0GnxzwCAqKgohIWF4fLly2jdujU2bNiAOXPmYMCAAQgNDUX//v112rJ582Z4eXmhcePGVr0PJCwTBEEQBEEQ+cLD0wtNW7QCAPQeOBir//gNI9+fiJPhh7Bs4QKkP0tDUmIiatappxWWe/QdqD3+XsJt/G/8aDy8fxdZWVnw8s5bjbdnz57QaDTw8/NDTk4OAgMDAQB+fn6IjY3VaUdaWhpmzpyJXbtUl/LINyQsEwRBEARBPOeY0gAXFkKiM50NyEhPx7dTPsfq0H3w8KyChfNmIzMjb+0ARycn7d+zp32J4e+OR8fuvXAy/DAWzZut3WdvL6wGaWNjA41Goz2XjY0NsrN1F5WJiopCTEyMVqscHx+PZs2a4cSJE/Dw8CjQNVpzBT+CIAiCIAjiJSLhdjzOnRIWZNnx73o0bdEKGaJg7FquPNKepmJ36GbV41NSkuHu4QkA2LJudb7b4efnh/v37yM2NhaxsbGoUqUKTp8+XWBBGSBhmSAIgiAIgsgnPjVrY83ypejfKQDJSYkYPGI0nF1cMGjoCAzq2gbjhg1Cw8bNVI8f90kQPh83Cm/06ohybm5F2HLzYcqL7pUM/P39eURERJGe0ycotEjPRxAEQRAEkR+WvFoZlarWKLbz374Vh4mjhmDj3nCr1tuoiqtV69PnypUrqF+/vs42xtgpzrm/UnnSLBMEQRAEQRCECiQsEwRBEARBEBbj5V3V6lrlkggJywRBEARBEAShAgnLBEEQBEEQBKECCcsEQRAEQRAEoQIJywRBEARBEAShAq3gRxAEQRAEQTz3DBkyBFevXgUAJCYmwtXVFWfPni1wvSQsEwRBEARBEEVOdnY27OysJ4quXbtW+/dnn30GFxcXq9RLwjJBEARBEARhMbdvxWH88NfQwK8xrlw8j5p16iHkh4VwdHTCoh/m4ODunUhPf4Ym/gH4avZ8MMYw5vU+qNvQD2dOHENgv0GoVqMmliyYi6ysTLiWc8OsBYuBKq4IDg5GTEwMoqOjERcXh/nz5+PYsWPYsWMHvLy8sHXrVmg0GsV2cc7xzz//YN++fVa5ThKWCYIgCIIgnnNsfp0PduO6VevktWojd/wnRsvERl1H8HcL0LRFK0z7bAL+Wf47Rr4/EUNHvov3P/4CADD5o/dwYM9OdOzWEwCQlZmJ1dvDAADJiYlYuWU3GGPYuHoFli1cgE6LfwYAREVFISwsDJcvX0br1q2xYcMGzJkzBwMGDEBoaCj69++v2KZDhw6hUqVKqF27tlXuAwnLBEEQBEEQRL7w8PRC0xatAAC9Bw7G6j9+w8j3J+Jk+CEsW7gA6c/SkJSYiJp16mmF5R59B2qPv5dwG/8bPxoP799FVlYWvLyraff17NkTGo0Gfn5+yMnJQWBgIADAz88PsbGxqm1avXo1hg4darVrJGGZIAiCIAjiOceUBriwYIzpb0BGejq+nfI5Vofug4dnFSycNxuZGRnaIo5OTtq/Z0/7EsPfHY+O3XvhZPhhLJo3W7vP3t4eAGBjYwONRqM9l42NDbKzsxXbk52djY0bN+LUqVPWukRKHUcQBEEQBEHkj4Tb8Th36gQAYMe/69G0RStkiIKxa7nySHuait2hm1WPT0lJhruHJwBgy7rVBW7Pnj17UK9ePVSpUqXAdUmQsEwQBEEQBEHkC5+atbFm+VL07xSA5KREDB4xGs4uLhg0dAQGdW2DccMGoWHjZqrHj/skCJ+PG4U3enVEOTe3ArdnzZo1VnXBAADGObdqhdbE39+fR0REFOk5fYJCi/R8BEEQBEEQ+WHJq5VRqWqNYjv/7VtxmDhqCDbuDbdqvY2quFq1Pn2uXLmC+vXr62xjjJ3inPsrlSfNMkEQBEEQBEGoUGBhmTH2DWPsPGPsLGNsF2PMU6XcSMbYdfHfyIKelyAIgiAIgig+vLyrWl2rXBKxhmb5O855I855EwDbAEzTL8AYcwMwHUAAgJYApjPGylnh3ARBEARBEC8lHBwl2Z22JJKf+1Xg1HGc82TZz9IAlFrRA8BuzvljAGCM7QYQCKDgYY9W5vGexci8H13czSAIgiAIgjDKtZqfwqUUg52mFKCfwu05hdnZAygcn2XOOR49egQHBweLjrNKnmXG2LcARgBIAtBJoYgXgFuy3/HiNqW6xgIYCwBVq1a1RvMIgiAIgiBeOEIWLMHUD99FzWresHlBhGXY2uEKyyq06h0cHCxOK2eWsMwY2wPAQ2HXFM75Zs75FABTGGOTAEyA4HKRLzjniwEsBoRsGPmtJ7+4dR1b1KckCIIgCILIF99HAYjKMFnueSJ29ivF3QQdzBKWOeddzazvbwDbYSgs3wbQUfa7CoD9ZtZJEARBEARBEMWCNbJh1Jb97AcgUqHYfwC6M8bKiYF93cVtBEEQBEEQBFFisYbP8mzGWF0AuQBuAngfABhj/gDe55y/wzl/zBj7BsBJ8ZgZUrAfQRAEQRAEQZRUrJENY5DK9ggA78h+/wHgj4KejyAIgiAIgiCKClrBjyAIgiAIgiBUIGGZIAiCIAiCKBF82q1OcTfBABKWCYIgCIIgiBLBh11qmy5UxJCwTGBQM8uScytR2cWy1XAIdSZ0qlUo9fZv4lko9RIvB84OVlnD6qWiYln74m4C8YKwbWK74m7CSw0Jy3qEftgOQ/y9dbZVK+9U6OedN7hxgYQZB03xPso3Wjx/qy02quICAPiohM1ibWystwpThTLCYL3rkw744Y2mquWquhX+O26Mbwf4Fuv5C0rX+pV0fq9/v7VFx8/o19CazSkUzgf3KO4m4INONYu7CQCAc9O6Y8dH7U2WexHWU4ud3bu4m0AA8PVyKe4mvNSQsKxHQ08X/N9rjXS2/fJmMxz8X94q3q1rlIePFQXotWNbYWCzKvise9181zGgqeLq4WZR0BUy29Yqj9HtfApWiYxRbaxXl0TkN4EG2/4aE4DFw5vjk251sGCouiBZ2PRuVFnnt50ZwnLL6m4my0zqWQ+/j/RH+9oVUL1CaaNlrSWfu5uhSWtTs7zO79jZvfFWQDWzz1G/srPF7Spsfn6zKcra52le/X3c0Lmeu1nH1nYvg9xc9cVKuzeohO4N8oTx1jXKq5Ytacwa6IemVV3zdexnen6L73WoAVubvCHLv1q5ArWtILg4afL9Hpays8F3emOMOZjTL7yMuDpptH9bS/tqbIKw97OiX1nu0BeC/FG6lG2hnaNupbKFVveLAAnLKnwZWA+AIETUrFgGVWXC8aJhzbHvs47YMqFtgc+zdIQ/AsTBz1tPuycX0PXRF/6aepfD2A41DMpVcjYtvJSxL5h5dd7gJijroDFd0Ew6mRAyzNFCXgjurvPbQWOL2Nm9sXJMAM5N647Y2b3h4qhB94bCKu6vNvZE2OcdzW7jz29aLlzLn0U9j7KYIw6YtnqzlXfaVzdZ19Te9Q22fdWngc5vDxcHNPZ2xV9jAqCxNf6pe7o66vzWt6boa07VMGfiNaK1+YKxEiVJZpg10A9rxraCg8YW7nrfmrnWnjIOdvCroq41YgxYMLQpvggUJtM/5ePdsxbmTIYkYmf3xtCWVbFpfFtt25VQs9y926EG5gwSvpGPu9bGpF71UaWc7nu6fHRL1PMo2CDfvnaFAh1vDKXvoaevB0rZWT709mtiWiEypp3pvuNFY917eVYcNe1rPY+yWkuiubzXoQYmdKqFoJ71dLbXMKF4MEa3BpXwf4P8LDrmxrc9DWQDU3SoU9HofiXZpbhchgb7F9wNtCggYVmFcR1rInZ2b0TP6g1HvdmcrS2DjQ2Djawn/Ly7oAWRzN7m0rWBrhDi4Sz4/i57u4WOgK6Pg0a3Ta/Urag4kDEzDIEVypQyWcaYIGlt2eUVEx+6vhZSaaYvF94dZfeqXe0KcHFSFuyrVyiNdSbM544aW0RM7Yo+jSx3mZncSxBw+zb2xM6PO6CUggAbUN0NTqWMT17CPu8IV0fdZ2ZvZ2PxQLlmbCvt3+VK59U3vW8DAz/2qm5O+GloUzT0VNemfd69jlnvWx0zNBiOeu/3l4H1tJMNfUFjYDMvLBrW3GSd7ylMJr/pL0y8bC2QwMd3zHMFGNqyKlpZoOkd1srQXYlzoHk1dUsB58L3Pr5jLcTO7m1RH+OlNwkyxei2xt+hifl0WRrfsZaqdUMSiPVx0NhicAtvxM7ujY+7Cv3r682raF0xOIS+YlIvw4mjOTT2FjTeEzvXxp5PlbWFShYpOUp9riR8N6vqil/faoau9d0RNbOXNsKfAWAWmPOkc7z3St77G6BiWerWoJLFLkBSW5WYOcC4YLfs7RYGiomiZGjLqqit15/8NLQplo7wRz+ZW6OLowZbJrTDyjEBBnWoufZM6lUfn/eoC19PXSFb7dnJtdq/vNnMYL+HswOWjPDHkBZVFRUGSkqgC8HdYScbJ/5+t5VBGSU+6iLEvTT2dlXUkpe3UE4pTDrXy5OBOtWtiDNfdSvG1qhDwrIFOIlCs/6nUr50Ka3QW14mdMwe6IeBzXS1AaZ8QyWtanPRxKjWietTydlBcWBU65MXDWuOP99ugQP/62hy1vpptzoob0ygFs/x4xtNtB26mslww7g2Rs9lLnK3iZoVyxgtu/Nj076FEi188gYhJU2Es6OdxRMiCUmoGt5K6Cg5BNO7/Bn9MaqF4rFyYU5J6Aj09TCrDeYI1JwrT4D6NvZE6IftcWJyFxwN6mywv7KLZYKZPvL7uu3DdgbneP8VYVCTJqkNPZ0RO7s35g1ugkBfD1Vzfy134f14K6Aa/hjlr7NvaAshPkHJtUESpvRR88+f0U93sHtdjH1gTBhIQ/r7IqS/rvAxrFVVLBB9ydU00eoOGsZZOSYA2z9qj9+GK08kjgR1xqWve+BqSCAivwnEnk9fQZf6ylYdSQAc3qoaejeqnK9gvzdaeBtse69DDa1lzRwYYxjR2geAYA0yhdozBIBStsJ7xDlHLfcyikHKcqWEkpXu0JeddATqVjXc8NeYABz+shPWjG2N5tXcsHRkC9jaMK1W3BJBGQD++7gD1oxtpTPJVHsnfMqXhr+PaRctOWendcOqd1th64R2Wi39j280ASAoYeRI70Fw3wY4NbUrOtV1N7Aq9pT1RRe/7oHpfXUtXnI+ESdBrWq4YcM4y4V8Jfo29kTXBpXww5Am6OWn2y+2U7AiOJuwiio9rk3jhXGslnsZHA3qjA8710JDT2dM7V0fXwbW03Gtk8bwFrIJzhSZZbBr/Urwr1ZO0RVN/9428XbVumQZm9ja5MO3siCunPkhT1kkvM3+1cph8Qh/HcVNSYKEZQvgKj2Uh4sD3MQH3KFOBez5tAOWj26JN1pWxdzXG+PS1z20nUxIf1+jnceMfg0RPqmz9gN2cSyYe0PrmoYDkauTBoG+HuhY1x3VypdGb7+8D3v2QENNgjETMZD3YfZr4oVJPesj8ptAk64USsgHYFOKPv2BUm6e1TebVStvmdlMqmvtWMs7b2Mm3UrODoid3Vvrbyy9TwzAX2NaYt37rVFaxSXmxrc9LW6LEnJXjUrOecKBvv+nfpChfOLg7uxg4LYBAN0aVjIYWOS/pW+EMYZ/P1B3YVoywh81K5aBp6ujVsBS8iLRP5f8+/SQXdu2ie1wJKgzqpZ3Qud6lXQ0LXa2Ntj1SQcsUhIoZRVO69MA56Z119ajRNtaus++U113xM7ujZhZveHr5YJhrQwHw5D+ftr6zNHK61PbvQwuz8gLvJNbK9rVrgAXRw0aqPjWerk6orS9HeztbOGgsUUt9zIG13A+uDtOTe2Kv2QauV/ebIbzwT3QV0FYnWJEyzumXXXMGdRIx6KRH7NUJWcHXAvpaaCdk39756Z3x5UZgWhfy/B7lNw+xotZZ+p5CPdHzVVJmoSVVrD4SPdOYo3YZ1Qp52RgAZG/n0qXfXxyF3QVJyvvvVJD2x+WK13KpPWiaVVXXAvpCY98ZCVydSoFB40t/Kq4YOvEdtj72Svo18QLsbN7q1omqlcso6qdlBQr5Zw0KGNvp3itXetXQqsabmgi3luNrQ38vAwnNn+/Y6gJlmNMJmSMYUpvob/r1sA8NzLAMGZGyRImuS5yzuHp6ohPu9cFYwzvtK+BcR11NdW13Mvgv4876Pip29vZgjEhRdrSkf5YLyqRupgxbkp9b1fZxNaURcigDhcHnJvWXXsdJ6d0Rce6xi26+eG9DjUUrRPvtKuOyzN6IHZ2b+13UaGMvUl3weKk5LasBCN9oFJgQdOqrnAv64DwSZ0R1LM+armX1boSMMZQ2t4uTzBiwKDm6j46GlsbVQ3dheDuqFCmlIHJWC3gIHxSZ8VMD1N76wrrcjPPGy0NtWYMQBkjrgH6s1gHjS0GiRr1WQP9EPlNILZMaIuFbzWDOhppHQAAIABJREFUi2NePXKzIgBs/6g9lo4QNH9uFs4uQz9sj8m96uGb/r5aDeS2ie1w4H8dLaoHAA5/2RmxswX3G31fSyWB5nXZ85RPTlqa0PDkvRMM7WtX1NFq66OvjZJ+akTtmJIgZgq5hnpUGx+83dYHAODpqjvg1vMoi/5maB2cHTToWFe3s5e3WhoIytjbobHiBEy4IY298/ZN7dMAo9r4aLWJxuDiDV05JgAHvuio3e6gsTUY9DeNb4M9n3YAIAyGSoEzVco54fjkLjgf3B2j21WHi5PGYrcGJZaM8FfcPrGLcsrAagqWn3mDGwMQ/J0ltx33svbae1dWNvG0VMm0WDZxcHbQqApFPykExZYxonG2s7XB4BbeOv1FfiYIgOCKY0xD6+KogWMpW3zcVej/fL3yJgybxrfFpvFttJMZyS1r+eiWmNjZ8BlM7ytkKnGyF96Rgvo4y1st10BWcnbAr281x6p3AzCpZ30c+qIzNo5XtsTpu0NtGt9W0Q96y4S2iq4HEvquSRpbG0VLXY2KQl8h7Sun4soGQPs+Sv3wEJklZu3YVvjnvdZYOtIfa8a21n6zgPBM9Sd29nY2BQrk9HJ1xIXg7joWtW8szDxTsaw9lulZ/Cz9pup6lDVwnYyZ1dtg8Q19t0wlgnrWw09Dm+qMNfUr6wr0+nq97R/qWlcZY3Bx0mjfGf3r2fVJB+3fh780jJ365z3zFEmTetXHmwGGMsXUPg20ckeWGNxsa1uCglEUoMSZFvBNf198s+0y7O2El75KOSfs/Lg9alQQOhBjZmgue32dHTR4K6Aq/j4eZ/KckmZ51kA/lHXQIHxSF62QtW1iO5yIeazqhmCJWfyjLrXx17GbAISO8ElaFrxcHXE78RnqVCprNJ2Z0p5A38rYOL4Nmnq7gjGGRlVc0aiKq07nOKlnffx2IFr7u0o5J1Qpl78sIy6OGoztoDujt0aqnfEda2HOzqtGy8zo54tGVVyw6sQt9G/ipS3f3Kcclo7yR6PgXUaPz08XId3GSs4OOPyloUsEAFVt1J5PX4G93sDKGMNXvRuga/1KaFOzPHZdvgcA+L9BfnituaH5HBC0GX8cidHZNqNfQxyPfoToh091trevXQEhA3zxbocaqFjWXvse9FRwH5ELUGXs7RD8qjC4SZOJtwKq4tTNJ+ivF/AkJZRwdrTTfqP6EzKJplWND8CLhjVHu9oVChz8qoSalmt8x1qYu+sacmSZMZaNamGg7QUAH3GiIxW9MiMQjAE7LibgZOwTnUwcSkKlMaG/e0MPxMzqpWpJsyZKrg3hkzrDSHIQA9rULI8h/t74sGttZGTl4NHTTO0+O1sbXPy6BzS2DHWn7gQgTMSVJuPVK5TGZ93rokdDD/T56bB2uxT45F/NDX++3VJnImIJipekt7GUnQ3a1BSet4uTBs1U3tNJPeujb2NPDPz1qNFzNqoiaGsDG3pg56W7BvvNCRoEgB0ftUdOLoedjQ261HfX1qtPzYqltWOW5ELgWMoWB//XCQlJz1RdboxNfCb3ro+Bvx7FwGZecNDYYlqfBqj31U6dMo29XeGpolXXd2UY3toHw1v7wCcoVPWchg3U/VmxrHCuwf7KfWN+MWcscNDYGlh11O6ftFXNxUvJXdKtdCkdd1KlMblldTcsHeGPd1ZEwKmULdIycwAI2uGHqRlmXEUeObm5qm0pSZCwbAGvNa+C1/S0wpIJzxQd67jjyI1HWp/lkP6+WiHAGKXsbHTMxnIzha+Xi45A2FxlBl7Poywi76Zofyu5dnzSrQ4+EWe5Y9pVx/e7rqF/U0/8r0eeS0ObmuVxNOqRwbFq/ZxaRy/HrXQpPJYNbs8jjqVstR1wZnZu3naNrVF/uNKipsrVyXDg3vfZK7h6NwXj/j6drzYZS30k+fDqY2PDtIJZj4YeCP2wHRpUdlbtiJUsZhpbG/zzfmv4h+wBALze3BvjO9WEe1kH2NvZak2ajDGcmNxFJ9gypL8vZmy9rJMKSo6vlwuiZ/aCjQ1Dn0aeWq26xPDW1fDF+vPabyw/+WFdHDXYMK6N6j0qKtaObYWbj9JU3Zn0n4h+ELJ8v6vse29a1RVrxrYyqdFljJmlPTsS1BlpGdnoNv8gAHVXNTm+Xs6oWbE0OtZ1N7AYuDppLPZ919ja6KT7rKFnTZZPeGpWNO2SpT/J9nJ1xJ5PX0G18k6qZuIRratphVw1uMzvqqDpOkvZ2ZjVv0rMHOiHA9ce4FlWjnbb9683RgMjAbtypMknALSvrW6uX/teazg7aODsYIchMh/1quWdFN2XmlYth4pl7bUWAAkHjQ3Ss4S+tFnVclj2dgu0qVlepx1yNhtx6zLFW62qYdaOSKNl9B+Xi6MG0TN7GX2OpgLVlZDSEY5uW92sdKx2NgzZudykkK32Wa56NwCbztxG+dKlwLkwkX+nXXXtBCNEDID+8+0WGLXspM6xkvJCbukOn9QZh68/xNt/ntT57vZ/3hGZObnoLvYTcmq7C2NCByPvVUmAhOUi4p321TGwmZfWpMkYMxjsC4q76BOrP2OWaxF/GNJEx9dJCT9Ra9BYT3vw+8gW2HPlHiauPqOz3RJTqr7gdfqrbjge/Qhpsk5cicZVXHAuPsns8xQFez7tgIep6oK+Uio/OT0aeuCb/r46bhwSNSqWQQ0jgYsFHWwl5g1ujOPRjxX3NfQ0rpmf2KU20rNytRYJCXmg3syBfqqZJtyddTVBgb6VEehbWbGshGThUDI5D/b3zremhzGGjePboGaFMqrZUszF263grhrNqpUzL/BNTzpVElZL29vhakggou4/hbebo6rAkR8kDfXQlt5YfeKWwXYlnErZYe9nHXW2ta9dAYeuPyzURTy2f9jewMVIjT2fdkAZ+7z3wNTkST+40xj6/eX/etRFbTMnZ4wBThrLn59b6VK48k0g5u26igX7bhTaQiPStz/cDLcpQBA6T07pqv3dpmZ5XE5IRrcGHth67o52vOxU1/IYGFOEftgObqVLGViPxitkx5DGLbkLjqnFo5aPbmlxmxp7u+LU1K5mZ6sI+7wjYh89xf1ky7S5ErXcy2oVYozpuojJ3xF99zo58rugsbVBp3ruBu+XZAnbKyqB5Ph6ueD0V90sdr0sakhYLiIYY8WWruXrfr7o/8sRVHZxMMv39JU6FXF8chedADBA0F5JflLfDvDFzUdpWHwwGg6lLHN979/EE6finmh/KwkFi0f4a02M10J6woYBtabssOg8hYHcnaaWe1nUUulD7GyYgY+aPowxbWYMc/j1rWa4di/FdEELGNisCgbmc7lzZwcNvunviyberqqBqJakZCtuLNHUqbFhXGuLA0rlmHu3pIlGK70AXrkfvBx7O1uztYgFZc+nHSzOGPPT0KZoMmN3oa4kacn113K3/gIN8nlMRfH+VK9QGh9YsLy95G4jsfezV6CxMb///bR7XXxagMWvCpugnvUworUPPF0dMKGTerrBd9tXx5JDMQY56i1BrgzYNL4NwqMfIT0rF+5lLQ+StCaWyAnebk7wdnPCpjPx2m213MsYTJrz6zqkhFMBFkapWbGMottoSReUARKWXwqkdED/62F+J6kvKEtUKGOvnTVyzvFZ9zoWa6qMLbss0axqOVye0QMPUzLzlcC/uFDquzd/0Bbh0YbuK5bSy68yeomZS7zETBEjC2G1Q0tRCliV/N5fNozlS7YmXq6OOPRFJ4OsJNIYWdRTlFFtqmP7hbvoWt/dwGJgDq5OpbBoWHO08Cm+VfkKhfRkwM4BsMsTBhgTFAQrxwSgVQ3L3hf9CbiptJnPG3a2Nlp3jbpGFpsRJrYxill58kPTquWMxjFIC5H0aGheis6iRrJWtK9dAYuH++NyQrKwXewI3Ms64L+PO6DHD4ZuEJYiJRSQAvKqlS+NC7dLltW3MCBh+SVAWr3O2jDGrGrS1ceplB2qls97Rf9+JwC7xcCzkookpMgT5Tf2djWa7zU/2NgwzFZZzKEkcGxylyIJEHvRmNHPFzO3XzFLY2Y0P3oRS8t1Pcri3PSCLU5hbq7w54rZ3kD1V4CRWwwcR5Vy/j6vVHVzKlI//0BfDywe3hxdzFxZtKB4uznhyoxAs1flLC7KOZUyiF+QkCYf+VXGH5vUBRnZOdqYgjJJN7B0eDM0reaG5mKMyosMCcvEc0PbWhUUMwOUJOxsbbByTECRmbxLKoU5iXoRGNDUC5vO3DbY/mZAVcVUS8RzTMwBnZ9WmcfcOQvsnwUMWQnYGrpATe/bwGTMgTU5+IVherHChDH2/+ydd3gUxRvHv7Ob3kNIIVRpUkQQUBEUC1ZEUUEUUUFRVFQQK1ix9y52+amooKAgUqSD0jsECJBGCem9J1f298fc3m2/vZICzud58uRud3Z2bnfKO+/7zju4uom1vHpCaEvArAC86OEhHm1ZL0UWwzvvAPDlEFx52bNA72eQGBWsuanKmQQTls9AHhjaGdf1MV4oxWg8/KkxOqt1ODoZbHvOOD15/9a+sk0K/IXA1Pktlit6JiApKgT3u1n4a4pFDwEFh4Cio0CiOqrSPR5uUsE4vbmyZyKGdI3Dk2780fv5y8JZ4Zjon9oJANj27JUGic8MWrZNgeEVM4b39F+jYOCBSzsbBuFvTNY9eRn+d4/nq6oZjcswbhfaE+9dgjiOyDYD8jfebvbRoik9BrzThf4/3Sg8itYRwdj67DDNHeGaBLsN2P4NYG0hoTotdUC52rrC8Jzw4AD8fN8gp793rzZR6JoQYbijJsMzmLDMYLhhxnU9sXzqUPcJGZRDfwK7fmjcexSlAw01jXsPA74Leh+rg55qtvvrIUaTUO7wdkaw52egpgjY96tn19ltwA83ApnrG6VYpph1PpC7j/7VljVPGXb/CCx7Etj8SfPcX8mCe4APe7lPp0f6aiBnj/t0pwM/jQbe6+4+Xdoq4K+pbpOFBvFY/filGGi0i2x1Ef1fVQDY/nuLsT2FCcunG0VpdIU1o0kRozPphUjzC8e3ADOjgYrcxrtHU/Db3cBfUxovf5sV+GwAMH88YK2nGqpmIJhYm+W+RlzYOQ7Lplzi3Locllrg9/uASvXubT5RkkXr6oHffctHEIDCo2YT03+ndtH7m6W2lPoNL7jXs7Id+RvY8Z37dHXl8ue79nXgp1HqdOXZwFdDgTk3uc/TUgfs/QWYGQNkbgB2fAtkrDNfdi3qHeNGXTMJ60qOLPPt+p9GAV9f5vl1v90NpBksSPvjAWDNq14XyyvSVwFVJixVP48Gdn1vLs/t39A6p8XRFcC7XYAjy4H3ugFLHjNd1P8qTFg+3fhsIPDjyOYuRYugKV0jEiJD8MrI3vi+MV0itn9N/x/f5HUWn449D38/domfCuQhRWm0g/aFrH+pEFZVoJ9GcGxgk7meamNeb6QV8TtnA8UZjZN3Y3FyO3olhrniLB9cBKTMB1a95N/75B+g/w/84Vs+O7+jWtdjJuq86I+dtgL4pJ/8nM3q/wnB3NuApY+7T/dRH+B9ia/oP+9QraceZrShK5+nfskQgE0fAUufkAvZSt/0w8touxHbnyBQoTBLI1TYf92v/dCfwM8akxmR/fOAf99ruvI0BpX51Irw02jt8ye20P/HHNu6py5pmnIpESfdYvsXBGD1TLqAsIXhk7BMCHmVELKfELKXELKSEJKskaYfIWQLIeSgI+1tvtyTASDHuy2QzzTWP3U5Nk+/osnuR4PlK+J66s3cm4kb+iab3oLd73w2kHbQRmyZBax4zvg8AGTvNHdPf2vJ7Dag3rHxy5JpwDdNV79UHN/smQY1exfw3VU0SoKTRhKMRIHr8FKqnfIWUXAsTvetPCufpwJrjcZulHrC4ZxbgI/7aZ/zhDqzMWYVfuQHFwH5B7WTlkreuzvh1m4D5o2ln8X2Z62nQqFMw23Sj/31NsCaV8ylbQ7yUqiA5Q5rA7DqRbkl9r8yURAVCo1tRTD7PPXcPMTJ3L659H9DFbDxQ2D2tb6Xzc/4qll+VxCEcwVB6AdgCYAXNdLUALhbEITeAK4F8BEhhK0+Y1CsDS7hxEOiQwP9FpQeANVmLnyImq7NcHQl8GFvKjD4hRbWkVvq6EDsK3YbsORxoCQTWPEssOUz3/NsLJY+DrzZjmoqgcYdbKqLgI0faQ84taXA/65Ta1CNqHJoVgsOqc+ZjS1lt7kWgGXvpELJiW3qdE7hVgDm3u46Xl3kYZ0Ry2Wm7ivSrHrJNQiLJv1KIxcmxTPIWCMXSpua+eOBLwZ7t2BR+j5T5uufl9YtMxP7YxsBSw3w7/va5y21vgucmRuAglTvrq0rN2clyUsBXosHNn0MrHvdu3v5i7oK6lq3/BnvxjqbhruX9B2sfxuYN859PhW5ruuU79Dj4MsepD+1C3i1tba1RTpZPLxMYqlqYWMhfBSWBUGQOs+GQ+MXCoJwVBCENMfnHAAFAOJ9ue8Zg7WBagCkFKV74MN3BvDDDVQ4aQmsehHY9wtwcCF9N1u/1O6oRHL30v/+XmTiwxaufuX1RODXO33LI+8ANSHv/I76zrZ09v5C/wt+mCQoWfkC1faJLHwQWP0SHUyklGcDb3eSHzu81Ng1RQ/loGi304VeWpoeawNtj685uuf0NY7/GoPcmpfVx6qLqR+k8lz+IX3fZi2hTg9lmk0fAfvmyY99MRior2o2P3av+Lgv9UduqAaWPum5QCW6b0kh4tDueGYlmcD2r9zn9b1i8yprA/B+T2qmr8wDXk9yWX+0qMyj/r52u/pc5gYgdz/w443A54Pcl0WLeePoJMcd0kVwNkn0j6bSLDfUuBYgv9MZ+KAHsO1L4B8P3TuK0oFX44CUBfLju390fV7/BnDYwI3CbqeTkw96ANvEOqB8DibGnJIs79wjTmyl/9M13ptYJwlHrSPiWhd/KGn8jM9xlgkhrwO4G0A5AMPI5ISQCwAEATh9HAF3z6EvO28/cP9azQDwXvNhb6C6AJgpMeN9NoD+F4/Z7XRAaQ4Bym6jg2qg59vXmuLQYuDk1sbJ21e2fEpNkRwP9Liemov63i5P4++O1x/5CQKw7Clgxze0vrYdoJ+2KB1o3VV+rPAoHVjjutDvvi7C+XKI6zMxMzc3eAaCANQUA8HNFHrLV8QoBGLbFoUimyKUl1ID2FADzLuDfp5xCgj2Yqe0fXOBpHPps1v8KF1MNFQRzeM1pQ7Dw/pY49jSfdPH9O+ZY0BoLPDFRfT4OVp+ojqa5fpKICAU4KVDlEZ57Fb1uTfbAqGtgGeaQGusJRR6Q8EhOune8Q0QGgO3wou0r1BOtgDX9YKjfNI6JV5rs1BLQJRBTP6qPKAyB/h7OjB6Nj12cCEw+BHt9AsfoGsJul0FtL+Qulz1vY2+yx9v1L6m4DCQ0EN9fPccoG1/VxzpzPXAsX/1y2oKH/pYQaDa4QET6DPb9hXdHOasoUBQGHDe3a6V4G+0AbgA4MViwC6ZmIptxCzi2oCUBdRFQXlci9JjdAIGUEvLK7FAX0f/kbkeCImm7VOKKF9UFQAgQEgUrTu1ZUB4PG2HopVrxim6INFTtn4ODJkKRGpsJqOUb6wmrbtNiNvRixCymhByQONvJAAIgvCcIAjtAfwMQKcFAYSQNgDmALhHEATdHoYQMokQspMQsrOwsNDzX+Qvds6m/m+LHwH2/kSFZX8sIFkyDfjzYfq52kBTVFtKnfRfiaXmWCVaZixBoAue9vzkezkBYNFk+eKp/INA6XH/5A0Av93lv7z8jeiH2FBFF1QufEA/CknaSuPV1UrWvUlXI6sQO3KDgTJjHRXipZ3d4aWuBRppq+iACwAZa/Xz+f0+OjFTlmPW+XRh02cD3f0KL1D8ruxd9DlnrjdnFnw5hmouRTcD6TW+TDRqy+ggKLXyKPOrLgL2z9fWyBZnAHvnur431FCtcWUe8M0w/fdgVqsq7S4XPmCQTisfybEVM1yaHC3fXiXiwH5kGe0P3aK4vzst1NYvXFqn1CXy8r/Zji5QA6hGasFE7Tycz5A+proyh3BdW2J+PYHWOzXyFf9tPHVPqavwLAyb6Fesh2jNMNKqrXqRtt1CR/+v1x8r61ZeijrN4ilU22ipo4uqlFp6KeUnXZaNUztpfRCf2/ZvgC8vpp/FNmSz0AnZ1lk0Asis8/Xz/vxCmn73HHm9XPwItRSIHPlb+/pFk+n9jyyn7+XbK9V+yvmHgM8HG7vplB439oVe/AhtPz+NApZPp2sDji6n7eqvqVROkGLXsErumaOfvxFHl8u15Se30/9akZNOaCig9okWM7s88kVRGv1fU0z7wfe6Ae91pf7/ryfR+vH3M/K8/nxY25qhR22p/Fotcvebz6+ZcCssC4JwpSAI52j8/alI+jMAzSWmhJAoAEsBPCcIgqEqURCErwVBGCgIwsD4+Gby1sjdT4XahQ/Kj+cfAObe4eokZkZTwae+Sp1H9k7qg6Nk52xzwuz7PYD3HXEXxZWrUpRmrFUvAZs/pR2UiTiM+Odd4H/DjdPs1zBxfmxi17Gds31bOJO7j/oupXkxexWxWaiG1PTiGx0EgU5aALnQQg/Qf7n7XKury7PlnYMWG94CfhmjdsERMbIizLmJ+hOukiwPmHcH8Os4OkCY8bG11rv8HLX8W/XI3U+tAWY5uEj+XapZbqgBvr0CeKsDnYyk/mU+3yKNxWDZO6nLzL55nmv71r5KTaT75kJ3ovJuF+CP+2i/oOSLIcAiSV+xby79e/9sKlgsmqwof5pjMwaFVtVmoWHHGhT9ibQ+6L2v8lO0DihRCtBmY1PPudk1IOYfcP1ua4N+ODVPfff/ng4UHaGfM9YABxWRNY448vvpFuDAAreTioJ9Ucj6OwH1FY5tiT/sTZ/LihnG5ShSuL2lLFD7iteVuzbQOOSo1ye3A8Vpxnl7i6a2GHSSLPVRFqMZqJDUrapCulbAibg40zHBttTQRVXKiVj+ITreiUi37V4yjV4D0EWFeSn0eYjv6PeJ8ggh7ig6SoXRd87Sniyc3AFs+0L72r0/0/vv/41+z94hfy9lJ6irQsFBWidElG0hbaX8+1zF5EYctytzAEu1uhxaY81ML5dn7ZxN5Yvcfdrnc/fSCabWWJ+5QX1MxG5xvqOSI+Go3igJR/i2ZLtq6Rh25G/5b/NkMe7BRVTWELHW04hHSsXjaRC0wCc3DEJIN9EfGcBIAIc10gQBWAjgR0EQFijPt0hEIUZpMln4IBVG8g8CyY7OdMNb9G/8X0DbgdQcAwDfDqP/r3sXuHCSF2VQ+Nzt+NblT6nFpo9cn91pqlY85/siq7oKKgh00YgWoCVQeMJXkg1AZpoQdnP3A627y91FFj5IB1gAuOJ5uhjvPk+Eby/dXj7sLTcBp62mg8nD2wA+CNj4gSvtL7cBd0sESq33ZrcDS6YClzzpfqLy2UDgKhPxQaWRJjwJRv+VIyTdS2Xm3ILmj5d/l15jV9w3ezvVDIltz1pHTYmDpwBnXwdESQLtnNiszu87yXartgag/91A2UlqTgxxs3Je1ABJJ0OiEAdQX1KRPXOAGz91fa8q1DAZuml/Sq29IADfjwA6XETDjqncVSS/syST+tIPkgjndeXyzR2ydwAb3gEufVq/LFs/p9rTwY8CnYaoz2tpw3+903hSo+XHrMWCidoL67TC9EkFJ2kf58QlFNYWUxc5Wz0PwHGd3qYXUt/xLwbTfmbX93Qx4z5FP1tfRSd1AND7FtfxmmK14kMqGBit6F/3pvz74aVAF4kXY61U829Qn7Ya+A+LvKdwtaopBgol9funW6CJ6D4jotQmVhe5NJMAjcQiYiZmsBSp4mD3j8DAe1zfzUS+AOTtVIqej3N1IRDUUfscQC0qM6Npf36Dou5pKcI2vEu1s8NekBzUeHeFR4F4hyLsr6nyuMk1JfS5imOodLxQUnZce22Fsv5KkbTr/D30ufa8PUc/vchnUsuAib5/369A0jnabjM/jAAi2wBPqMTFFo2v0TDecrhk7AdwNYCpAEAIGUgI+daRZgyAoQAmOELM7SWE+CFeT2MiBr9XhK8yEkJ/uIH6KR3fLD++dRat/L5uMbr0CbW2oSRTJ86pRjmXPQ18dSkdDNwJyoIg/602izpe5x/3U+2TvzbQSF1CB2+9mbQeVQVUiBMXBqx60bFZgmRetvY1KoyZXfRjrdf2hVSiVx+kA93Sx6lgUJFDNSDSkEyZ61zmNEA+8Ih5L3+aDh5mNPrKAWrta/I8pfcVWfc6Fdo9WTy22suYvVIhUPnsNn9KO3mxbPMnUN+7pY8DHyi2bBVdAvSev6jh+ugcKuTMjNbW9lsb9LXQ0gnbMoVvr3ORDNSCCOCZSw5Ahcxj/1JBGVBbMGoVLhN/P0OFrYJU2v5EQU6kutBcBICjyz1zhfJE+w/QQVHcJQygfY+llrZNLc2p+LulZmSzAnj5Sc/KJrp4SPlrqragIQ2/JtV+L9RQgqx9zfVZyyIosuEt+ffjm+BZZBAf2P8rMEsSL97bBcrbv1IrdbxF2jfU67i7uSNNy7XNgGqJm6fdrv9bakvU9UVLSK0vp/GZ3W3UM+t8agU78Lt6g5EvLzF2WTHCbvevm6QIIfKxJV/q0uOoq0or6cJJDhcaHcHaMGpNy8TXaBijHC4Z5wqCcIMgCKccx3cKgnCf4/NPgiAECoLQT/K31x+Fb3LqHVrOzZ/qD9RKU5YgUBPugnu00wPUJFGS6Xl5vriY5qsUmMWy7ZxNB6td39OOLXcvMPtq4zwFgeb5ssR8tGQanQxIKXTMCpVaNalm5Z/31I3IZqUrmnMUVeDXcdT0KRVSRGZGq03ZIuIiqewdtOzKhQtSPhtI/WQBulueVKtang1nw17ymPsJhd2mNpdL2fOzwz1HUk+0/LW+u8oVcUL0Q5w/wSWQeWqeylf4Jn42kArqUgGP8PI0R/+mvmp6GpxtXwFLWQaNAAAgAElEQVQ/3+r6vvkz6qeop8nRQ7rZiqdb7mqVTamdFtkzR/57AZcJXcpr8XRNgDhgrXsDsGm4xuz9Wf5d+YyVHNWIO6w1aRHJ3mGcn9R0LLLhLeqKJX0vWij7qRKF9rammIZL9BW9qDHShUizr6Z+kHqI8aFnX+M6ZtSeAW2/UD1ZU7RE/HK7+pxR/9vUi5BF9wYRb7bp3vq5+zT+EHT9FWf+60tdn5sqEsK3w6gGdGY0vf/K5/2Tr5mdImuKtNNVePA87VZ5+17zsjmliqcYjXOCQK00ryXQhZ8AdSUTEdfP6F17GsF28NPC3Us8sEA/vE9dhTysizN4/xI6GItIzWDvnw18cp7n5RT9plRmJoFqaJdMo4K6kQ/zzGgqrM+Mpv6oL8e4Kr2I1qIEcSGGVDMKyDUra191CUU2K/3Nxen0WfzhoWvK3p+pNuqNtlTQVg7OJZlqn0cl5Sepn+zeX4D/XUtjP657g+4e9GFvqnFRUnbSNUmSjsJLpqkF6krJ7PvPyXRVftkJ1731SP1L7e+241vttFIO/C5/3gCdyCn5oCfVUJc5ymAqKoWE5U/L/fkEG3UteUO1B5F5lKGQ/I2opRWRRuWYGa0tfFebXFCst+ZAdzti0kgLJmEsuNeWwZSW0shsa5bFOmu7/35W+7i/MBrIlVQXAn/P0J7MeNP/KvFljQVA+0uTCDagvlzuRWmtd0wGMtYCKw02/hFRRmHxhrkaEw9fWfMyXUTZFIjWgbwmXmDmiT+3HqtelI/9mm5KfsBoDU7GGtci8fkTqEuksu/VY6eJreRbED6HjvvP8tE52sfrymhoJhGpuWbD267PUjOYj6S/uhL2hiR0v0XiNL/Ng9Wqn/Sn/z0xyYqmsoUPuEKqaS38Wfsa/QuKoAPbSBMaDz02f0rz+PpS4MKHaEPlJKH8zMzoAcc2sg42vA2EtaaftUxru/7n+lx6nGp9Bk4Edv+gTisuyNRCqZlXojSl263UHK230Acw/3tFDi2i2pMoP8a1FoXO8R6a6Bvb1KwVoqkil67ubizm3ASM14h3WmnCJ7AxeLsjcLGJ7ZoB836heuybq328QGeHOj081TatetEz1y0zGldv+Vlna+FGIG9PNMrSw9H1xjwEhtlRVxqArBUJaHNhKWLm3Nxk5Wg0Di1yn4ZhiM1CcPT3Nmg7pARR7Rsx7rjU8iaua9FD6sOss0urYAPAeb1qqNFgwrIWRk71ImajLFRomH/1MLtznPKyKo3XmOuBp4vWyl5PqMyjmualBgOzqAH60+FOYTZutHTRj1Tjrbcy2hvM+rrNG0fNZO5Mw/6gNEtujvYHopnRE1OfWdxNBkwiCIClikdQZCOYYj1pE97ywwjTSQUBsDVwCAj2U6xeLcz0ZS0JTzdtANz7iJ6B1BYGAQBs9RwCw+yoL6NKg+q8YMSc1fJi1DKanoZKKhcUHYpoXGHZWzQm2IINODw/Ga3OrkKixiXNCXPD0OKoTjzHxsaEptBaz7ndXMxuJbCfksc4rcoJRvqSBP+4g2UrtJ3vn+1ZOBkApueNn/b3MF8v0NqhTIvGEDL/q4juKQpKDkcgY2ki6krNzeOtdRxsFpN1yWiXq2agODUCaQuTYKnm3Sc+w7DbNCIxAsC61zQOmqSlqaIak//Sb2X8Z7DbaMUuywhr5pKoYcJyS0JrO0gFaQuTcHJjK8M0Rxa0Qdqf8oU0ebuiYakKgLXGDwOzVqghTzcY8dRvthGxW4HcHdGw1TfvCGS3EBQfDj/d1j34lZoiqiGzVJsTltMWJSFjSYK5zP21WY+fqMqhoQ4t/miTpxlH5icja2UzxdE/A2mqLsNax6E8K7SJ7uYZggA0VP332tIZSQucDLYcieU0x1rHoTo/yLdMtFbia1Cd6377abulhb9aT30ZG5GyrDCUZYSj8EBUs5Yjf18UCvZGo+pUI20v3sw0VPEoTfe/xoDG1WWcboiuA/7mTJ5rlh8LRW1J4zw3M2T/2wo522JhqW1540tpehgyliRqPp+yzFCkzks2b4XSQLZDpJccXxuHipNN2797+4utdRwsNS3vPTcX7EkokWh3BTuQOi8ZJUfdD/DHVrXGiXWtG6VINgtpWdpGM7vE6SAIQN7OaNRXtEB3+WZ+xvYG2q2JpqgzjeNrWiNvZ4yuK5Ddh4Hs9MS/Fa4yOwRVucF+zfN0Qqv2WGo4lGW2DE2orYE4XU9O/tMKWSs9Hy9ytsbimEQjLwj0VzdVy3EKyXbP71iVG4zUecloqPRtcltfEYDUeckqwVX04xZ9daUUH44AAJ8sq4UpkXSHyHJ1/nYLQe7OaLd9WE1BME5tMrYMtxTSFiUhfbE61GNdWQCyVrRunP66Jck5CpiwrOSnW2Ct46hPnUNoKdjnXuNo1mzsKbYGuqK1cH9ko+Tf1DRUBKA0PRyZyxJQsLf5f5OllgMcA04LbqenDbUlgboTIVu9fndTlhmKI7+3QUNF82nNWjrVBUGGA1T2xlY4uSHOq7zLskLPSBP28bWtkbs9FsdWtfbd8ucgb1c0yo+7F8BrCoKQ+msbWB31/ugfbZCzlcavr8oJQV2J9+URtfLiroVm+67K7BCkzkuGpbpxhn5rvb4rWfkx+sxqi3x7DxUnQhz/dd5BI3XktcW03NY69bMrPhKOsvRwFB8Jb5yb+0hDJY/UecmoKaC/QXR384aCfVGoKw1CTaF/2pMU8dWZXf/flDBhWYO0RUk4tTnW1eYMXpyRxrcqL9gnsw9AV8sDBh1DM6Kl8bbWcihMiTSlCS8+3LzCsq2BIP3PJOTvcU2G/LHYqq40wNBcV5kdYmzOM9nZW2o47UVSDmpLAjU79sbk2Mp4ZC4z6UMsQfTf1dIK2W3wWRvVojHxvi21HE6sbY2cbTGqc4LN3D4OJUfDta8XgNxtsTi2unEsY82JGCmotjgIpzbH+iXP0rRw5Gxx5aXc8FSk+HAEIBDUSgSTihP+dUNqKJcLPUohw1LDycpWlknvX+fGBSZ/TxROrIuDtc58fw7QelSwNxp1xa78Gyp5v1lG7VZ1H1F+jLpYaFnkStLCZHXe23Kc2hKDmgJqtSk6GInUeclO4V+wA4IXmnYptgbSqH11dT4tu1jm46sbf71AXWmA6YXaToQm2sXSC5iwrEPVKZdwKlg5lBwJR1lmKCqzXf5G9RU8Dv+aLPNBOvpHEgpTImGp4XByfRxytsSi/FgoCvZ5Jhhmb4xFSZqkYzVRd/L3RiFvV9P43YoxHJVa95ztMSg6GOmz9qApECciYgMtywhD+l+JTm2Nt2StSEDW3/oCY/bGVobn9Wio4lF0MAKCQKOipC+WC/pKjq2MR+by5llEJXbKWtSVevZ8c7bGImNpouZmbSL1Fb4PyIUpkcj827/Py9ZAPPb7s9ZxsoHTWsuhYA+Ng1xfrn52aYsTcWS+eoMYwQ5kLItHhaPPyt8djfIsfWHN1sQTKy0aKnmn5tAsdiuBpZZDTaHDBcXHemCt55CxLB7FqeGmfFSPr2mNw79qPH8vy9FQyZsWnIxuUVsSiPTFSV5FFig5EoHq/GDkOvpzUSPpDtFf2O4QHqvzg5CxNNGjRYGCoJ785e2KRu72aORsjUXFcfp76ssC0VDFozCFjq3WWvWEOn9XDMqzwgw1lTVFgYZKBwDOewJwCs05W2Nhqyc4/FsyShxuHt6S9mci0hYZ7G7ZyGQup2OFpZpHVU6w50KuBlkrEpC1IsEji5VzIsQ0y6cZkp4of080crfHIlsSiaKulHYglRJh2dbAoehgpNOFo74iADlbY1Gcqi0sV5x0mMUUCyYqs0ORv0uuBbI1GNegksMRKE3TabQalwp2V541hUGwerBoQ/SvrVCYI+1Wh0uDID0GVOYE65bDW+rKAlCiMHsVHYxwDnB1ZQEoTtXvxFQdqOB6Zy2Rk/+0QmFKFKw1vPP5V+ks9hTfq62eCh+Hf2ujGoAylsUjbbG20N5QycsnayaQvvOcrWotnnj6+Op4WvdMWl2q82jdsdTwutdkLktEhYGAriRnawzS/5L/9qKDkXQAdmixj6+NU6XxlMy/4zX9/uT3jXD6QQp2atmSDpw522IMLUt6CxztVoKGikDkKrTJqsVZflLilGWE4eQ/2v6Y1joOebujUH4sFJWn9P2qM5Yn4NTmVrDUcoaTIylHFrRBuiT6T62Be0PO1hikzkt29UcaVJ4IQUNFIAr2RRtOalN/pW3KnWLAU5NyxtJEpC1ORGVOMKrzPFM6SPvwBkc/ZlbQ1ULsz83UkbrSANjqaF201XOoLXa5ZNWVBBm6YTVU8s7fWrg/EkfmJzsF77xdUShNC0dZZjgqs13toConBBlLEl0ukI6iWqp5FB6IcCsAi2U+vjpe5eZItcXur7c6fq+oWfbWfUCwyZ+N6Jd98p9WSJ2X7HE9oJm6Pjrfo0756ssDUV8eiMwV8Tj5TxyyVrjqva/Ko4wliajSaW+CQF3AxHC4x9e0XOsWE5b9gpGfhv4pSw2HkqNU2HO3MlwA9XnzhqyVrWUbl6TOS8apzTE4tTnWmefxNa2RtSIelloOx9fG4cjvSboVHIDzJwtK05ej07DW8DjuMOPl7Y5G9j9xmrNVo1ln5algww4ra0U88ve4dh4TBKAwJco5wGWtiDflb67CpPBQV+ZYaOKHWbg7BAFOf16pUGqpClD5T1blBsvqSsG+KAh2guq8YNkCsIaKQFhrtMuetSoe+btiZM/fZlFrSYtTXZMTt9YESbnzdkXj6O9tdN+v1B1GjOySuSwR6Yv1Q9UrTcu2BqLb0ZcfC9NdZ5CxNBEFeyNRUxAsSyMIQGlGmEcLW/SeLwBnG6rOD8HxNXEQ7MDh31waSrvVsXGJJLKNR25COvVYFCwtNRyyN8bi+Lo4WXncYbcQTRes3B0xTncaQO6ekL8nCqVHI5CzNRbZ/6r9qq21dJ2I2H+k/5nk9L8W7NDVzmtpfuv12iOh7x2gWnafEYimNtN13vHP7oWJ3U6Q/U8cTqynwoNgo21G7x4i1fnak+eaokCkzkuWvR9T6NSJzOXxODzfNUERbLTvFTm1qRWOrYqXjWvVea5715UGwFJLLSjpixOQsTTR+VtFxdKpjXTCrasA0ilqYUoUig5EOV1OZKjcBun7q1NYbDKWJMjaoh7K/qUwJUp3wugJouuO+L5OrG9tOMk0hAAFe/Xru7Ru2hvU9fTYqnhU+zDhAoCT/8Q5Y6sXHYpwToQrs0OQuy0WhQcVysQWqFlumSq0ZsQz0xlNbKT10RuQC1MiUaSsIBr4w89OayGJlu+ctY5H8aEIp5kpf080IpILDPO2KRqXuAhC1CyWHA2HxWFasVk4BPBy6ShjSSLaXFCKvJ0xCEusR4dLSwBQf+/sf+MQ17MSCX0rtW8uuFqUZvxPx/kT6+JQnR+Mnre7th2uKQwCF6AviVflBoMPtCO0tUU3jeiSU3EyFCGxOmX0BB3tf/7uaIQn6YcVzNkSi+iOrl279BZeiEJKVIda8G52jXN2mpIyZS5LgLWWR8/bc2Ct48AFCHQysi8KbYeUgAuQN56SI+Fodbb27pCiO4DdSpCxNEEV6jB/TzSiz6pRl8tkSMTakkBn1IAeY3JQmhaOwpRInD06T5ZOsGuH/Jb60x9ZkIRuN+ehtigIeTtiUFsUiOQLtXfwtFTz4IPtqmdRUxCEoCgrAkK0n7vdyqlcV3K2xsJuJagrdr1PM76RqfOSEd+nArFd6bO3WzjNKBk5W2Odbd0TjvxOJ2LRnWqQPIhGxjmxwSUglKaFIU9iFet8XYFuuYsORiAiuU6myRKpKQxG+bFQZ1/S7aY88EF25/sSBOhoft0/I0sVneh2uqoQoXEWZ36CDSgysEYZUXI0DK2616AsM1RWp7IVcfE9jVhireWQvydKp8/mkDovGVEd1W1FFK4rToQhMELfqd1Sy4HjBfBB6sFPVIaUpIUjPKnBedxupT/Q1kAMlThlGVQZpMxZfN9RHWtgMZpQeoBy7M7b6aqD0kmmIFArSFQHV59pa6CacEGgk36zZcrdrh6fzUxI9PodI7L/jUPn6wpgqeYRkaw/HtSWUGtSYn/aR0nH/7KMcCQNlPddZoT7E2tbo8eYHFmZa0sCdcuROk890WioCEBtcRAK90dBsBHE96l0jjOGk84WAhOWvaCmKBBhrS3I2aJfyTKW6mvAqvODTAnKgLag6wtaiyAqsqWN2/MpnbWWQ0CovvAldmKWah4BIepOW+xwqnNDUF/BIzjK5vSfLE6NRHCUFRXZIWh/San2/es4Q38vcXGDlONrWoMP0h9ARK2WVMCuKw0AHyQgMNxGZ8iOuMzFhyIR2sqCgFAbAsPleRYfDkdYQgNCW+kL3QDVUEg3p6gpCoS1lgchQGl6OErd+B1a6+liv0Ct96AYRJSTu/KsUPAhdkS0MY7zLe3QlM/71KZWaH9ZsexY/p4oXWFZxFLN67oR6A3CtgYCwgmGg03xIZfAIwiQWSCkFB2MRHwf44mO3cqhrjjIaco0iuuc/lciQuIacNZVRbLjx9dSrVmPW3NQcTJUNlADVAhWWkFqCoO8jiFdcjTcKSwDUEXJsFuIWlAWiGyCY6mh7Vo0LQt2oGC/q4zlx8KQPKgMgl0e+z1focUyqruFKVEyjaQSqTtPZXYI8nbGIK5nJaI61CI4RttPo+JEKAJCbWjdS/5eRRcBKcdWxTvb+LFVrTX7W2sd55zkKC0h0jBi+btj0Kp7jbM/4zX6OkD9Ltyh3GBKiqickPrUikgnlsWH9Meb9D+TwAfbqOJDIAiOcfVVorWIruFR979mrZ1l6RJ3OckQoyz3sVUuM7yn3kFGY6Uo3FflhkCw1SNvZwwKD0QiaYBDoCwOwrFV6vUKqfOS0X5oseq4WahSwQ5OR9Ky24DKk+bdxzKX00lG0sAyxHalE6T6CjpOBEXS+la4PxL15YG6oWyVCyTNyhh0sWeUs14VHYhCWHwDwhMb3FzpQuxDxf+1jvUrdiuRhXhsgYpl5oZhRN5O7QG2NM238DD+iMecOi8Zqb8ad1RaEQSKDqg7zVMbpVoh129rqAyAYKczSDFGZn2FI09JbRY7c61g6xXHQlFbRAfl3G2xMm2wFpnLElULfHK2xcoWXBanhst+m+jT6im2Bs8EkawVCUj/KxG2BqISvrI3UrOjcje5gr3RsrioSqpygpG3MxrHVsWjttC1cOT46nh5PE43zy1tYRLS/0zyalFRzrZYjwbw4lSz9Z84/Q5riwNlv0HUNFZ6sQFLQ2UAjixINjSTml2dXp1vPmKNKLgpNUeCnWpIxQFAqglWcnh+MnK2xmoKkGYFY+k7NnSVMkDUDivJ3xMNax2H+goe6YuTUHI4AtX5QSg5Eo6KE6GaC5mUETaUrlmCjRj6q5pF1BQWp0Yia0WCoYtWyZEI3QmSErEf1RMa0hYlwVZPYLdBVeeULiXSd6MlnKvurfCf9niBtkZ7rzgR4tbfNntTK5RmhDk1gLZ63rVmQ8clMG93lLFbkUlUrnsSaiVtx1oT4LP5X4mlmnf6GdvqeFMxj0/+43k4RlsDQU1RINIWJeHIAvqMpRMrsR4V7o+STQhtFoLSjDC3Y1pZRhhqiwNReSoYmcsSkbE0EdX5QRAEubuLJl6uUTi2Mh7lWWEydzupe6c7tNxixElU5clQuZa+BUrLTLOsQNqQ/R3mB5A42hvcVwvNTsqNAHVsdWt0HSF3o1C6Tbij8lSIrEPJXJaIpIFlqvLWV/CaC0mU5iwzbiW1xUEy7YaIIADWGg4F+6JRsM81EGotJvMJyXO1W6m5TDobrysN1J0wiRoMLfJ2RgOcvKdy1xEbRZXQTO/nrWgJodoPabQF6bOXouXLe2xlPALCrLqDrDduAGaQCrTSHRHtVqBeEsu5tigIx1bGo8v1xu5G+XujZJo6WwNxmq2dA59EQ5o6LxmE15dYbHW8cwGWpxz+NRnRZ9Ugvk+Ffv3xYdHeifVxSOhbAYBawdz5/WtpNaWIpnh/oxUBRIqWRUkTgbiUADqUZoSjcL97QdabePgFe6JASAWCoy2m/XONOLW5FeL7VBgnshOP+4rSo76XDaC+7WY5sda/C77KMsIbrT5KUWrcy7NCkbNNPU4pt7o/qjOJVWKt41Wa8Oq8YITFu9fyurNSGt1TDxosgINgI+ACtfs9f9Tt5oQJywrMhDkhxPuwQHrRGbI3tpKZ/M2i5RskYqvnVRokT4WTOo0FUlJfMJHMZYmI7WZscge0Q1+p0lQEoOSI+jlV5QQjyMD3TkrGMv+EABO1AlK8tQyUpss7aTNbxur5NyrzEvF1m3O7lQDEVblT5yUjurP79wpAV0tjpI3yRljWMpcCdEJTciRc9cxObXaVK3dHjEq404rtrESpdcz8Ox5xPasQ1lp/cFKucJdSlRPs0zbd5VlhhsK2rYF3G0tXD6lmUTmYK/F60VET4EmMe3cCvxlBGaC+vZ7SUBno9WYygo7CxMi1xUULVN+doWgJyoBnLhhStHx8i1MjdaNuSfHXpAegc3JBUFtc3GG3EUPZRToGtRSYsKzExDtqqAzwKq5i6rxkxHQ1Fjyq84OcW3O2BDzZOMTXEDMi1Xrh0Op41Jo05xrtBOduouOJ5sMIaWeg1TGkG/giimgJXJYaXnMyAVBNtBjS0JXeXDOvOBEiEyydeWa2zF2plFTlhLhdXFOr4yJxaotn79xaE6AK7egJynekhTth2t226P5w93K3o6JWZIuWgmBg5VFidg2JP+/pl/u5qQNGnA6x8M9kDIXF04T8XdGI0ViI7Y4yHWVPS4YJywrcDUAAHXD1Bl13VBvF98wOUa2cPp3w92JEJb4KsZWnglv04G4WI9OkGSFMDy1B+YxDZ6LkTrPYErGcgdtTMzzDF2GZwfAVwU481iqbwVcLaWPQ8krUzIhxOBsLIy3f6Swonw6cCYIywzf0Qjmejhj5x/tKzlb/WFcYDAbDU5iwfDpgYtceBoPBOJPxxZ+awWAwzjSYsKxAb8EEg8FgMBgMBuO/BxOWFZjZD57BYDAYDAaD8d+ACcsMBoPBYDAYDIYOPgvLhJBXCSH7CSF7CSErCSG6SyMJIVGEkGxCyGe+3rexOB1XxTMYDAaDwWAwGgd/aJbfFQThXEEQ+gFYAuBFg7SvAvjHD/dkMBgMBoPBYDAaHZ+FZUEQpPtqhkMnkikhZACARAArfb0ng8FgMBgMBoPRFPgl6Cgh5HUAdwMoB3C5xnkOwPsA7gRwpZu8JgGYBAAdOnTwR/EYDAaDwWAwGAyvMKVZJoSsJoQc0PgbCQCCIDwnCEJ7AD8DeEQji8kAlgmCkO3uXoIgfC0IwkBBEAbGx8d78lsYDAaDwWAwGAy/YkqzLAiCoTZYws8AlgF4SXH8IgCXEEImA4gAEEQIqRIEYbrpkjIYDAaDwWAwGE2Mz24YhJBugiCkOb6OBHBYmUYQhHGS9BMADGSCMoPBYDAYDAajpeOPaBhvOVwy9gO4GsBUACCEDCSEfOuH/BkMBoPBYDAYjGbBZ82yIAijdI7vBHCfxvHvAXzv630ZDAaDwWAwGIzGhu3gx2AwGAwGg8Fg6MCEZQaDwWAwGAwGQwcmLDMYDAaDwWAwGDowYZnBYDAYDAaDwdCBCcsMBoPBYDAYDIYOTFhmMBgMBoPBYDB0YMIyg8FgMBgMBoOhAxOWGQwGg8FgMBgMHZiwzGAwGAwGg8Fg6MCEZQaDwWAwGAwGQwcmLDMYDAaDwWAwWgQzHo5s7iKoYMIyg8FgMBgMBqNFUBAX0NxFUMGEZQaDwWAwGAwGQwcmLDMYDAaDwWCcgTw5kW/uInjEbxdzAGnuUqhhwjKDwWAwGAy/YjmvR3MXwWc+v/70FpEKooETCQSH2zV3Scyz4BIOlQ2VzV0MFad3TWAwGAwGg2HIe7c0/VC/rUO92zSfjlCX6+BFSX4rg9XHn73+XA7jnvSfZnZnV+9UplMn8dh7lufXfnUdfQCvjJX/howkIDvOq6I0KpYWrARnwrKCiGHDmrsIDAajmfBmQPqvUBfY3CVgeMv2s/0z1GfHAfs7mWsjGVXHMWaG8UKtqlD595II4OXLirwtnowX7uSxoY/59jxhmrakZgkk+PhG+fN78GHeK0H8VGv59+fu4lEQ7fr+5EQe6Rpzhdw4gtQOnvdNKWfRQloDXNduOIfgtdt5PHMPj/um8Jg6ybyEWhHqPo0vEKFx8/cFJiyraMFvi6HJvKGsGp/pPHNP46kcfruYw0vjeNw2nccbt52+damxTcbbu3s2WG/qSfB0I743X7l3auOXrSys0W9hmjV9vZ8ITrvf9axWnWecjyj8KQWf/13JYcM5+teOmRGABx+lwvUTOn62SwdqX//t1fK6//Q9PI60J1h2vrk2MWZGAGpC9MtWoXiPJVEEdkfyvBhTtwAA5zUilgCgKMr1/UQCwZ8XaZd50UUEn9zAoTbI/X0WXkTw5XXa+aw+j0N1KIElkKAinCA3jiAn1lz5X7qTx/wh5urRPY+p3+G4p3j8dYH+9UxYZjAakZbcwBhyMhOBl+/wrNtZPoAgK4n4bFKVUh3s+rzgEg6pHQgEQgDi6sh/vsz3G353VdN1sevPbVnd+ScjOTSY0EbntNI/9/ZoDlMeUA+6yxRCU2EUHZztHpRPa8h+bBKP5+8yFqKl2tI3b+UwZrp2+gce4bHbA7P73Y/r31eq0XtmAq+rsa0JgkxTKeXra7Xrxyc3cDjp0HjqCX7SPnZbDw53PMXjSFvttMcT5L/51ds5zBjPY/n5HGbdwOPv/vS8kdB1MoHg4Yd4TJzKo8hEyN2VA1y/bWdXgmNJNO+T8QRjpvP49AZzbeNYgvZxpZALuOrPhj7yvF+9Xf5dLP+PV3AQFPlIv249W35SKcAKhGDjORzGP+E+rNrcy3is7afzmzXGS61Jxbgnebx5q1TlAPEAACAASURBVLz9nWpNMH+odj2V1p0xMwJQHap+aJYAgjnDXNcrFV0teSxvWb1rC6C4vrRR8397tPtHXhEKwxl4Y3L/lJarCdKDE/zbwsqbWBsk7YiXD/Dtvf/by7/15vfBvuUnHXyeupfH9HsDcLCjvA3YdG6xuSfBmBkB+N/VtE6KA40//C9fcCMQAUBGG/1zywYSrOjv/tkcbUsw9mmqtf5wpLbgZwapC0RNENWKPjPBldcDj7SsdksFA5N1R6f5LryIYFc3Dnmt5PmMfZrH91e66sDMOzg8O55HdShxaxmoCdb+DNDnmtMKOKXjy/nSOB6fKISuPV052QRL5K4neJRGEnxzLYf1Oq4AW3q4jn91LYe6YHW67d0JHpvE477HXAJSdrx2+QBg8sM8fhjmKuPcoRzGO9wLBE67HBvP4Zyv4K8LXdd+dxWHBx/mZXVLbIPWAIJ3RvOytjhmRgDGzAhAnkPIE++WchaHjGTXvWdfQ4X9+UN5lfAopTCGoDKMYPLDPFZKtNmbero+v38zp5o4vHOroi0Qgn/P0a8XR5Ndn5+/m8ejD/DISgQev8+Vz6GO6oL+6hD07IqsyyJcaSc9yuPzERwqQqlGvi5Qnk9RFLDOMcmd7dCOi/UyxaRLmKfjlVauWu/BEkiwpyttf1Me4DHLwHI1ZkYApjykL8Q/dxcvm0S8MYbDO6M4/DFEnudnJic1zUHLLVkzsbN4r895HGqvPUOfOJXHrm6uR65noiyNANKTfRd6tjlmqscSaMPf0oM4hXUtbc4rYzmUh6sHpqbigIc+WdvOJqgNAg564csl8rrG4PqWsrP1gHclg4dZTehxiUCZ3Vr+W164k8ejD/L45VIOj03iMe4pHh/cpJ/xpyN5POHo5IsjqebLWxZfSPDbUA4vj1XnYbaDfnoi7UCtHHA8Ufs9TX6Yx8EO9LNUgPjoJvl7EAf0FAOfyVyFNkZPEM+O189D9BkUANz/qKsMS88n+GI4fRbzhnL47hoT9YQANp5qrbf0ogOP0u/vRGvtS0V2dSG4+0nXQPTyOB5VYQRZbVy/oTTSv5OkvBi1W8fCwebqUnoSsMQhdJnVFD38EI/MRPmxuZepn+8TE3nYeLkF4FBHDuUOAWV/Z4cA4zgnNVk/OZHHVMlkxcbLn9mSC6jgWx1KVNaPzT2pz+hGA6FLCxtPsPhC7Wv+7e26f4mO9vT9mznkxNF0UydRQdgSoP2uH3mQR00IwQFJ+1g+kKDWwL3AiSPJkXYEKxyC6YkEgpIoolu3KsOI0xf6H8lv2dqDHvOb/z8hyHFMmAiAjyX9wrYevokw457k8dKdrvwaAgnyWxE8c2+ArI8QCMFX13HIjaXjOAAsHkQF9dX9aLSJKQ/weGcUh5OS68oiCA504nDfYwGoDyJYcgHBgY4ET0ykE4bKMIIN59J8RCE7pRPBZyM4/HgFh6+u5TR9xKfdz2PKA/RPz5Kgh1abFPM41F77mrxWtJxK9NIrSWtHnP7TALC3C4ed3dX5edq+mpKWW7IWjNLZX2TMdB7T7ucx884AlUlUbBhSTrWWa5BFDePObq5j0oHVjLZZOntb6jCt1AZR4eDDm6mw/tptHB6/n8f4x3m8PZpDisasWcTGE7w7isO7o7R/8yMP0o7DjJYNALIS9c/9q/P7NvYizg5Kyv5OBOOfCMChjhxevZ3Dow/yKn8udwL44XYEJRFui21IA+8qz54urvudiqODrDukpqjV5xG8f7Pre1E0kB9LsGgwHTQtAQQWN1a4k/EE4x/nMflhHnu6ciptdYbJxeZ7O1Mh72Anufbo7dEcpt/Du13ZLfo5zh3KYcYEfcGyNJLg5XFUK/WVjp8dAOeAbuOoCbc4kmrkXhrnylspdPw4jMM+kwuSROrFOkTgFMIAYMEQDuv60oFNSwuohZaseN9jAXj4Idr2nr2bx8xxxkK30pUhK0nRjxi4MZhBy1/x58s5lIXLj51STOReGkf7ENGlRTTlezKo2Anw9q08CmMIPr1R/zksGkTwvys5nFSY+DM16vKYGQGYoOHScCKBqJQBehzsyOEFiRClnLip8o6nbjuiBUAqkGTHE9ypEVHBSKsKUCuRVBucG0ew9ALtp/vxjRwKYmnaWknd1KunyrHkpOPd1gXSNvPhSM70grKxT/OYJdEIprWlFiHluzKixoQfrq9o+cpaAolq0qTHmn4cpj6oHscrwwhevCsAea2IpgAoxRpA8ModvPGzIQT/9OFgCSRYcx6H18aq686p1gR5reifp1OSExqWiX1daH1/2U1fpOSVO3jDaCGe+Mnv8jJSSFPBhGUvONqWvtRZ13PyFbSEOAeUPwYTU1pZqYnu9ukBmDiVx29DORx1aJa/uJ5zzvp2d3FfmUQtBC0nsK4PwefXy8uxvzMHO0dQG0xkmm49dnTnsEPRCezoRjvEglj6X+lvpUScYBgtTljXl8Ntz6if2aZe1Bwnmvm0SDmLQ34sQZpCI//67RyemeDyk5Py/TAO9UHEOWgtvIh+KJTM1LV8Tu9+XO4zmOkw1y+4WO6TJhDtQVZ8VjXBdGDf05WTXEOwrQdnyk9Pyg/DOJkfZ20wcZrB/6f4DQ2Ooh9LoO/RU3Z141AcRfC1kWALl3C1cAin0ior/fpEjBbZpDnMpQIB5g/l8dAjAVhzHh3Uf7yCw9azCT64mcdzEheL5edzeH0sj4cmu46ZtWAoBV0tHzythYc1wa52XaozESuMoW0vvS1BlWTwvecxXqV5/vYa17NSug6Mf5zH0yY3HTiaTH1ylT63T03kVZEA9DR2M8a70qV2oH2IWL9yWhFUhgBzL3VdmxdL/dTFcksnjyURwEMP88h19FmnWhPd9v3L5dTnVcq9U3mZQKvH8gFE1xJyx1O8s90rOdLefNt48r4A/HmRq/0rr3QnGIvnZe3ezTU7uhHs60Sf2abeng3lXw7n8PW1rv72y+HUglQQSxd+beklz8/qeMyVGtEQRMuJLxxp59n1n9zAqQQxLb9iKVJf2Ycm83jMgygQLZlTcZ49O61+DKD13dP3aOdofdHjq+u0x3Qt3vbBotsU+LQBNyHkVQAjQa1eBQAmCIKQo5GuA4BvAbQHHYOGC4JwzJd7NxZ/D+AwJNUmO7avE8HrY3nEVgp08CP6nboTQmBz8+7tBDjYicP8iwUccgzg4qw1qw1dOWoJILhnlcOoaFCPs+OAdsXyDsPOEXwxwn0FzGkF9DkOVDsElfHTePzwoU2VbvoEHr2PC7hrnXoZzSGJAHKgA8E5JwRYeKA+EIio0x4s6gKBEAv9PHmyy69uRX+Ca3ZTUeWpe3ld870WH97EodcJAU/9Qcto4wmy2gBZbXhcu9sqS7tMoaVZ0Z/D3Mvk91oxkMPEVcbLhqRClY0D0tsAXXOBjDbyvPJigKQyoM4xYXDXueshaq0yk4DOefSznsaJXuC60ZMTedy7kr7b/13FI7UDwW9vWjUvc2dBL4sg+PAmDtMW0ecz5woOu7oSfPS1uu4oOWHgBjF1Eg9e45G/M5pH2yJomqGXSEzdlRqCUXG065pX3GhPlGbKzES1NlckK4n2BYklAuqCgYtSBeztTJAfC/wwTH9g0qM6lOCRh3gE2oCBaQLaFQnOPuGL4RxSFQJcrUkN9/yLCeZfov7d4kTNYjIsXIaGe5j4uBoCgYnT5P2ijSeYfm8A2hYJmLzEhhX9OQxOtSErEXjmXp+GH9kkQ0l9IG1vcy/lsKUXh/9d7To3dRKPiDr62RpAUB5GAAioDjF/75IIoFWV+rhem5G6ZD17N48gq4DQBtcxUeCZ/EgALkmx49Eldrft793R3gsXNp5gtcQPuD6I4KCBBSavFcE313BO1z5/IbpXuIu0ohw/Np7DYeM58mMTp/IIcN/1AJD3B43BunOJzDWlMfnmWg5DDtkQYAc+HMn57MI5dRKPIO0hwcmBjgTnHDfhY0WI24niF8M55HsQUaS58K23At4VBOEFACCETAHwIoAHNdL9COB1QRBWEUIiAI8WLTcpR9rTwU8qQIgv299+gaL5R2sQAzSEAkfdTG9DFygFWeAUat+4jcf5RwWUeeFS8OOVHHZ2F5wCgZ6PW2YbgrhK7QYicATjnuQRVQvcv5y+3rdu5fDoYvq50NE57enCofspOwLsVNsUYgEefZBHkU7n5YmgDFBhY8fZBJ5UMS0frqmTeLQr0v6tdQrt+PEEgp7ZAtW6EIJnJwTgrFwBJxXmrt8u4TDlL7umtnHyZB6h7mP4AwBKHa4BezsT7OhGkG6wEE3k/ik8up0ScELD/PfUvTxaVwjY3ZXg17dMjjYOtvTkMCBNwNCDAsrC5JYNI8rD9c/l6uRRG0yQrrMC35/8dSGHXiftToF+ugmhLt8x6P8t0e5XexmTtC6YoA7AOoXmbF1f99rDz6/nMHmpHVUhcAqEp1qp+5jHJvFILDUe7FLbE+fEz4gKx7uUhsBScqo1wXMTAtApr2mWuwsc0V1wpKxffw8ksARwWNPPfF/z8GRes9+YfTWHCavtqFdMPgSO4Nm7eXACkN6WACAIrxVQHUwngYUxrns3poj15q3qiAxmWdXf/4bogliCu57gVc9LiWgNM0pnZmK6vTtBlQeTIm/54vqm05I2BBLMGsFh6mI70toS3bHULHr9r5RX7vDf7zPTr7UEfBKWBUGokHwNh8bEmhDSC0CAIAirHNdozMdbHlvPJhh0xFzHXhQFtK5wn05k1XnEo8UPyk5ZABW0a3k6mw6y0Jny8vMJ4EVkCEsAwb7O8vI8dS+PLrnqvIxytwQSFAcCXw3ncOM2Ow5IfKELYoD7pvCoCANW9qcDzQffUMHM2117jDr96mAgXCF8TrufB2cH3v9OLhDmtqJaIqkvcG4ccXYar95OtdWjNgtIawPV6vcfh3HY1Fvu05nVRl24jb0JbDyHAx0Jbt4iL4MnHVxGMsELd/FIS6bWAzOUhxPsdGhviqOoJk30rzyeSJyTkgnTeDwz34ae2TA9aq/rSzD0oIDDDq3n4/fx6JbTvDGA/rqA4Prt3pVhVzcOY2acHh24HscSqebnz0EEP1+ubmA5cUR3YiNGAagPohM/peXh/Zs5XLvLNRnddxbBu7dwpsKk5Tv8o/8cpP98X7jTOEqCv7FzBKtMrrkQ0fNz/acPh3/6aP+29Lbya6pDCe55XD0E7+pKkB1nfkGlJ0hdvloK9UHun/36cwmiazgsMYjRa4b3RrVsU7+3bOrNeeyK0xg8dxeP7s3c9zcWvmqWQQh5HcDdAMoBXK6RpDuAMkLIHwDOArAawHRBEDRVWISQSQAmAUCHDh18LZ7XLLyIw6Aj5rRsz9zDI84DYfmba71rsPmOBRyrz5OanBtnVJEKUFKKougxpYuBlNJIgh+upL+xLAKIqaEuB2JZa4PFvKiQatNp43oLs8ZP4zHmX7tuSCYAmH4Pj7Oz5Y1WFGZ/H0ywX7Iy971baFq9Z5lyFoeUs4Ds1nbZSnMRawDBkXa6RXFBCLb0JIiocd+ZuHPh8dTHT8rX13LY1VXQFOhrQohjVbaABpMLXw52lAuX2fHEMNpEUzBnGI85JjbjLPbQN7yxMKPBNYNYswqjqcWm0MOV8oA6UsgzE3j0y3TV2W09OLlPMxGtOe6pDXbvwuaJr/CZSHUoweOTfB6aW+R2xt5i4wn+MLkZBqP5SGtHkObD2NSScdsiCSGrAWitn39OEIQ/BUF4DsBzhJAZAB4B8JLGPS4BcB6AEwB+BTABwHda9xME4WsAXwPAwIEDm22KktWGms3e+NGGIjcDTmUY0fST9DeVoTDlK92YHEsieOI+Htluwl2JvHEbjz5Z2oLoO6N59DkmyCIOAMD8izlEV9t1dySrDSH44SpjaTI/ljgnF0p+vVR+bXUowW4TC928nbnraVqNKvcbY3hclmJvFGGuPohgs0E85q+u43Cwg4C0JnB5aE7GPdm0GkwjXr6DR2St7/ls6kXQLYfg16GcVxNprVBQWW2I5sSK0XJ54BFetRiU8d/msxEc8nTGRIZ73ArLgiBcaTKvnwEsg1pYzgawVxCETAAghCwCMAg6wnJLIr0tDeNlJgpFY1IUBcRXuFYku00fCcy/pPFMMic90BqWRRD8q6MBrggn2KSxCKIinOCDW84cc5lS0yoGsS81EIRz44hmnNmmoCaEYKUi3NyWHgTtC/0/d1XG1m1MVvUjOE+iITVaxd3U1AcRV8g6H7AGEHzrpeXK7USccdrg7/U1jNMfPfcghjl8jYbRTRCENMfXkQAOayTbASCGEBIvCEIhgCsA7PTlvk2Jr0HP/cF7o6gG1mwHOPkRNug1Bc/ezZtbEaygJoTg4xs5WQSRls6HN/tZcCcEL9zJ6+6W1hh8c92ZMwFjNA1r+hIcPkPNygwGwzy+SlVvEULOBg09cByOSBiEkIEAHhQE4T5BEGyEkCcBrCGEEAC7AHzj431PK3xdfVsZZmw2ZzQP6W2JatGOWVrCYozm5r/um8po+Xw1nE2wGAyG79EwRukc3wngPsn3VQDO9eVepyv3PMabdp9gMBgMBoPBYLQsmL2+kfF0UwIGg8FgMBgMRsuB2YIZDAaDwWAwGAwdmLDMYDAYDAaDwWDowIRlBoPBYDAYDAZDByYsMxgMBoPBYDAYOjBhmcFgMBgMBoPB0IEJywwGg8FgMBgMhg5MWGYwGAwGg8FgMHRgwjKDwWAwGAwGg6EDE5YZDAaDwWAwGAwdmLDMYDAYDAaDwWDowIRlBoPBYDAYDAZDByYsMxgMBoPBYDAYOjBhmcFgMBgMBoPB0IEJywwGg8FgMBiMFsGdPe9s7iKoYMIyg8FgMBgMBqNF0C+hX3MXQQUTlhkMBoPBYDAamWA+uLmL0OK555x7cE2na5q7GCqYsMxgMBgMBkNFq5BWHqVPDk9upJJ4h6flbwzWj1nv/GwX7KrzoQGhAIDHBzzeKPe/v8/9mDVsVqPk7W++uuorTOs/rbmLoQkTlhkMBqMZWXPrmuYuQotl3oh5mDagZQ6ezUnK+BSPrwnkAg3Pj+g8At9e/a3s2KrRq3TTP9j3QdWxv0f97VGZ/ClcL7l5iepYEB/kt/zdMW/EPOfns2PPdn6OC43DqtGr0D22O+4/937VdVvv2Irvr/0e43uPx6A2gzTzvqnrTV6VqVdcL0zpPwXtI9t7db0Wv9/4u9fXtglvY3h+cPJgEEK8zr8xYcIyg8Ewze1n3+78/MFlH2DGBTM8un7KeVPwy/Bf3Ka7scuNHpfNVz674jN8cNkHeGHQC4bpfhvxm0/3CSABsu8c+e90w08OfNKj9L3jeuPec+51fr8g6QJ/F8lJz1Y9Gy3vpuLbq7/F/rv3q47/NPwnLLtlmeG1b17yJi5scyHmXj/XeUxP2Lyz552Y3Hcy9ty1R6a1JITgrl53ATD3rn+53tUXPDXwKcO0esL++jHr8cFlH6BjVEfc2fNOXNruUuc5u12tyTXD3rv2uk0ztf9UTO0/FQAwJHkIesf1dp577eLXZGmTwpPw+42/44FzH1DlwxEOAxIHgCMczks4T/Nerw55VaahfmHQC+ga09VtGQVBACB/dle0v8LtdUpu7nqz83NcSJypa86KPkt1bOXolR7fu6Xw3+mlGwHloGeGTlGd/F8QHWKDY33OY+sdW/1QEv+i7CRmXjSzeQriI8F8MEZ1G9XcxfCaqzpehTt63qE63iGyg/Pz5L6TnZ9jgmMwsc9E9InvI0ufEJqgyuOe3veYKsO86+e5T2Qyn0vbX4qrOl6FW7vfKhMYlPSM80yoig+Nd37uGtMVf938l9flfO/S97y+ViQ5PBnPX/i85nOXMrnfZNn3fXfvM32P1aNXax5vF9HOdB5KCIhz4c+NXW7ElrFbsH7Mep/6uRGdRzg//3bDb7i+8/UA6ED/+bDPnedWjFqhurZ/Qn/T95H2+0FckMeTBimilnHDbRtU5wiIpmaub3xfJIUnqY5rCWfntD5H9l1Lgzyy60gQQhDABWBou6EY0XkEHuv/mLMMgEtQ02PagGmIC3UJXl1juxrWscU3LUb/hP44N/5c2fG40Dhc1fEqAMAzFzyD5wc97zwnwLgMevAcL/uuNXm/r899TgFZKcj3aNVDM1+OcBiSPMSrMkmf1VUdr8LCkQtl57fdsU332naRrnb38RUfOz8vGrkI28dtx8guI1XXrBi1wqmRfnnwy5rlAKB6HwAw8ZyJWHzTYuf3KztciX7x2ov2mkMx4g1MWFZgZrbWMaojACAmJEY3jXQmJuXZC581XRapoGEWqdmsb0JfzTTSTn75LcsN8wsPDDc8Lwo1FyZdiNahrWXnhp813PnZjDbulcGvuE0DAN1iu8m+d43t6pVZUos3Ln7D+Xn4WcNxfx+12QxQC+jiAOEJoQGheOmil7Dnrj2y4ynjU5AYluhxfgDVDomIA8h3V3/nrHcXt73Yef7H6370OH8zg8/MwTORMj4FKeNTZPdbP2a9phZ1zZg1qufs7j7XdboOj573KHrF9TJZcmN6t3ZphQjRFjgAOLWcz5z/jGF+UteKtWPWYvY1sxEbHIs5182RDVxK2ka01T03+5rZuKbTNVh761p8fPnHqvPfX/u97rVSV4bJ/Sbjth63Yc2YNYbtpm+8vP/gCIeNt2/UTS8lJCBE83hCWALW3roWABX8U8anOPtTI9aNWYd/b/8X58RRQe6KDlcgIigCcaFx+O0GV9+SMj4Fm8du1sxjav+pKquGcrL6cN+HnccvaXeJ83hyhMtdQOwjruhgXkM3/YLpzs/DOw83rANSNo3dhMjASNmx5y58DoC2P25wgLkFZKKQd1n7y3TTDG03FAAVCm/sciPu73M/tt2xDT8N/0klDL55yZuY2GciAHlfaBQCTDlGDmozCBzhNMfOlPEpaBfZDj9c9wN+Hv6z87jW+CXVfIpl4QmvSucJYj8zpK1c0L0g6QJMPGciXhr8kum8vrzqS9Np7+9zP9665C3VceVCwT9v+hNhgWGqdAGcvkKPgKBLTBeEBoQ6ZYVR3UZhUJtBaBfRDskRyVh2yzKkjE8BIQQhfIjzOUrH6lu734o3Ln4Df9z4h/PYYwMek93rw8s/xJzhcwAAN3S+wXm8Y1RHvH7x67plbEkwYVlBt5humselAqaoFVAK1hGBEc7Prwx5BVd1vAqvDH4FXaK7OI9LB+HJ/SZj89jN2HXnLs1O5aF+D3n3IxwoZ/aP9HsEs6+ZjR+u+wHRwdEAYNhpi2afB859QNNEOWvYLEzsMxFhAWF4qN9DmHTuJNn5p89/2vnZyA9J1ETqCffuOLe1emarVw4lIXwIbup6E7rHdsfuu3bjhi6uhvzy4Jcxuvtozetu6XYLPrrsI+d3UXh5bchrmun1ELUzvtIhsgMCSABGdB6BPq2p5vaVwa8gZXwKLmhzAcb2GIuU8Sn44sovnDN8af3Yd/c+jOs5TjbBEVEO1nq0jWiLIclDcH7S+c5jUi2yVFszvtd4w7wECLijB9Va33b2bSqhLi40DpPOneSVf9t3V3+HlaOMzYGtgtWCyGtDXsPD/agwNa7nOF3NYqeoTkgIo1pbUetyftL5+Of2fxARFKFKH8K7BMtBbQbhm6u/cX6/qM1FAKgZV3yu8WHxzgmj1JdxQOIA3d9z7zn3Ytsd2zDlvClO7anI8luWG2rSpUQHR2PBDQsAABN6T9BM89WVX6mO9U/oj3nXz0Of+D6ID4tHyvgU54p3vYmm1JzeOrQ1ooOjcXmHy7H8luUY1mGY81xSeBK2jN3iFOQjgyJlJnGR+/rcJ6uPKeNTMDBpoCxN+6j22HDbBtzd627V9aIf6g1dbsCym5dpptFDpVjRmAsOTh4MwCVYTzlvCqKCojCyq1zrZ1Tn3fWFIp9c8Qn6J/R3CqbivUV23bkLn1z+CQAqmL1+8euY0n8KwgLDVJMoPQQIskmodEK8eexmxIa4LAJXdrjSOZF+ZcgrGJhI38uHl31o6AetNX4F8oHO/nhw28GY0HsCVoxaoepDlP7ZnaM7A4Dqve4YtwO3n3077up1l0qhw3M8HhvwmFNR9M3V32D2NbN1yyuip5QT24KopLq47cWy9jq572TMGjbLKRiLFgux7CLi2KRXVzaN3SSbVErHgm+u/gbLR6knIRvHbsS2cVR7LbpYdIvthpu63oQbutygUmIB2vXxjUtcCiktP/OWis+jNCHkVQAjAdgBFACYIAhCjka6dwBcDyqgrwIwVXBnp2kGtAazQW0G4fMrP0f/Of3RNqKtU7gbkjwEAxIHYNbeWbgg6QK8dNFLuH6hq2J/cNkHAGjDuGMZHfg7Rrq0KA+e+6CzMj91/lOotdbi9zT3zvOtQlqhpK7EbboRXUZgQ7bLVPdAX5e/1NKbl6LGUmN4vWhueeS8R9ArrhemrpsqOy9qHsQG1C6iHd7YRhuC2DHFhcShuK4YQZz+QoultywFAORV57n9TQBkA811Z12n6hCmXzAdb213zcaNqtkLF72gMgMF88Got9XrXvPu0HdBCMGwjq4B+/IOl2PJzUvQMaojOkV3wpxDc7DimNp0K/8Znlf/KztciQ8u+wDn/ijvhKQmr1nDZmF/4X7Nugxod6Ac4TD9gun4dM+nqnOLblqEYfOHqY4rmXTuJNzS7RbNc8rJ4NB2Q/HDoR+c340mbVquS6IgrWR099FYcHQBusd2x9HSowCAGRfMwJvbXRr3C9q493ttE9EGi29ajBsXueqGVGghhODqTldjd8Fu2XXvX/q+01Vg4+0bdTWsIn/c+AcigiIwtsdYzD1MBVbpIp+Zg2fimt/VYZTaR7bHvBHz0D2mOxalL9LNv21EW7w46EUAQFhgmOYCo3aR7WTP/+K2F2PjqY2aAh0AnN3qbOy9ay94jsf3B7+XnXvxohcxuO1glNeXA6CC67+3/QuOcLoDt94zBmneUQAAE+pJREFU+mzYZ5rHteqKsq6/O/RdDF84HP3i+2Fvodz/9KmBTyGrIkszb0A/gsLcEXOd0QzaR1Hz9LQB05BWmoYlmepBf8p5U/DJHipwKhc2Kdv+6O6j8fyFz8Mu2BHIB6J7bHeP3DxEzE4eE8IS8MN1tP1pWRd8WRgnTgwigyIx4v/t3X14FNW9wPHvL2+EJOQFgQRMMARCeFMCRF6ikIBUglIIBRMBA9pytVZbbLUtPGr11ntLK+JT1Nsqra1NxWorPkKrVqPGXm8uKghKLPhC9SpQIK0WWmtR0HP/mJlldndmswlLNi+/z/Psk92Z2dnJnj27vznnd84UzWHV86soH1TO18Z/jZ80/ySwztFY00hWSlbQPpz3J6tXlmdvS25aLoc+OuR7DJUFlVwz/hpqS2p9vwed3rsV41cwMW8ir3/wOre8cAuZKZmA1VgkIoHPZ6RGF4ffAL1Q9bPrefztx9n34b6g5ReVXMSWA1tYW7GWD45+QEnfkqD1oQ1oD1z4AIePHg48Xjd9HU37mxjedzgA4/p750A7/2OoSJ8fd2u28538pTFf8t0eYP3562n5qCXiNmDFI8fN8Va3i6eTb9KCNcaYGwFE5GvAd4CgJCcRKQfOAZxf+P8BKoDnYvD6MXVt2bUU9Cng9pdvDywb238syQnJ/GDqDxifO5689DwaFjaQm5bLPTutVpTSAaWB1qTQLpIz+5/JzqU7OW6OB+U2uT+YCZLAxSMuDgTLv/n8bwCrleaa567hX8f/Fdh2YPpA5hTNoX5XPZPyJvHiQe9cpUg5iVm9sgKty15CW5+iCexy03P53Bmfo+HdE6kgzvMye2Vy14y7OPjPg/zHi9G3vjYsbGDX+7t4/+j7fHfLd8OOxZ024VgycklQsByJV6tWRnJGIFju37s/A3oPYFjOMP73z9aZeNWQKs99Od3JY/uPZWzF2LBgOS0pjY+Oe5+gLB6xmAdeDx/4tql6E/MetYK0pkVNpCele36huVttc1JzqCioCNsmlMFQN6qO379zouXG3Wp067RbKcoqCnyuARaNWMRDbzwUtJ9xA8axo2WHbwuh14CjUPOHzScvPY+Wj1q4senGiKOmq4dVB4IVt8qCSm6achOTB05m6ulTuX/3/cwunE1BZgGLRy7mzF8E50rfVnEb1/3BP3fUPUDF78cFrPdkTtEcsntlMzjzRL52pPrlcFpjnFbL0KmlnM+613vr1XrqKOhTwN5/7OW03qdRfnq573ZefjzzxwA07W/y3cb5vC0dtZT6XeHpPBnJGQzPGc5VpVeF5X+GWjd9HXWP19Hyr9Z/VKNVkFnAfVX3UZxTzIbdG3hu73OBdUtHB7ccXlh0IY+9/Vir+/QaYOak5TjB8s6lO7lzx52BoLCxppFth7bRN7UvZ+edzdaDW7mq9Cpe++trQfuZOXgmiQmJJGK9V+7emcqCSu7ffX/gsddnISUhhU8++6TV/6EjLBu9jMyUzECrtTsYry2p5fhnwUFRaPoetJ7vvHHuxsAJmZcESQikhfjp17sfWxZtIT3Z+k4dfdpoPvn0E2pLaoHw3NxY6pPSh9oRtZ7H5KTH9U/rH7beaz/uE48Zg2cE0oM2zdsU9H0UifO9X5lfGdX22anZUaU+pienew70CxXtccbTSadhGGP+7nqYjnd7hAFSgRSgF5AM+J8WxlF6cjqXjbksMGjkq+O+ypVjrbO5C4ouCAySyEvPQ0SoLallysApLB6xONCN5DWXooi0OnWPY3jO8EBOWPnp5WGjTwXhm2d/k+ZlzWGDpdycIOeKs65ge9123+28uAclgdXaVFVY1eqI5dsqbgvLwXVUFFSEfUG4u6C90hHy0vOYMXgGFw2/KGg/YA0Yay2FobUBdF7pJfWz61k5cSWpSakkJybzTM0zgdQbZ05MN6eFPdSj8x4NyiF3d6+HWjUpeFYJJxByD17KTMkMCzxmD5kdda63wz0A51tnf4tna54NrJuWPy2Q61yUVRRo2Vg3fR3fmfIdhmYPDdufe0Cf5+t55ACH5qmKCOWDyqkeVk3zsmb6pPTxbeUIzT9MS7K6JO+cYbWKzyqcRVpyGpefdblnUO2IZuL76mHVfKH4C2yq3hS27rzB59E7qTc1w2s4q/9ZJ/WF7/yvfielreXEO/XVSZkJ5IafRN9dNCfIftskJiSyce7GqPJ6B2UMCkvhioUJuRPITMnkyrFX8tCch3y3W33u6qhmP4iGiPDFMV9kQfECloxcQr/e/agqtE6ufzbrZzQvayYvPa9NvUqTBk6ieVlzIOXGK+//wTkPntSgwVhKTkimpqTG8yTphsk3cHP5zVHvy+9zn9UrKyYBVkZKRqDuJSYkcsmoS0hOjPw7/cvZv2w1jawzKMouijrFr6RvCTvqdkTVyBLJb6t/6zmeIlT97PpOeUnrSGLRsoyI/CewFDgCTA9db4zZIiKNwAFAgLuMMbt99nU5cDnA4MHxO9soHVBK495GhmYNjdgykpOaw/rz1wNw7NNjQOtnxa0J/YKI9MV6denVVBVWcUXDFbx/9P3A8gRJIL9PPk8teIrc9NxWp6eqLall/rD5JEgCX3nmK2G5ur0Se7GmYg3PvmcFVn5dhAmSEPRaq6eu5u5X7w4K+p5c8CSHPjrEH/b+Ieh1+vXux9qKtTz17lOeKQy5ablMGjiJOUVzyE3Ljdiy5ri5/Gbq/2idqY/sO5LctFwWjVjEhLwJfPzpx54thoMzB7Mkc0nQsuKcYh6b/1jYiPJIZ9dOYDm9YDqNexs9Rw2HcrZZPXU1ew7vISc1h2snXMvP//jzoO1WjF/Bm397k1un3drqPkNdMOQCtrds9019+P7U77NoxKKgLsBIQU970kncrdV+8tKs99pp4bnnc/dwRcMVYfmVm6s3c+CfB9p8DNG45Zxb/I8vPY+XlrwUk9dxeqNCT8ac5UOy/Vtnnl74dCCH8dsTv80NTTcETija2p3unh+2LdsPSBsQVXerH+czVFtSG9ZzcaqJyEkPAHPLSMloNSAM/Y2Ipg7dNOUmriu7LigAWlOxhtTEVIpzij1zRivyK4JS8boK5ze3tV6Jtho/YHwgdaq9M2WUDijtlJdjbs2PzvuR54wojliMnSnMKqQwq7DV7cYNGOc7TV5nFdW7IyJPA17v8vXGmE3GmOuB60VkFXA1cFPI84cBIwHn17lBRKYaY54P3aExZj2wHqCsrCxuOc2B1re2VCg7xm1vJXSEPj+/Tz77P9x/4mVcLW6JCYmU9C0Ja4VzvowHZkSeBBzCA77GmkbfbafmT6VmeI3ndEJeygeVhwU3gzIGMShjkGdlOb/wfF46aAUgoTOHPH3Riemo3N2Ubu5Blo7q4mq2HNjCLefcEtTl19ZLj7a3JWNt5VqOHj8atGxB8YKg1nKwuhadSfrTktMCgfOlYy7l0jGXBm27/Mzl7ToWgJqSGuYXz/cNpFISU3zf30hiPZl83ag68vvkBwZzlQ8q5/na58MGS+Wm55Kb3r7ZQzqLqsIq9v1jH5eMslpbnCCnX+9+3DPznog9SO7/3fnuGH3aaGYVzmrT1ITb67aT0MbOxrlD5zLqtFFs2L0hqvEWftzfeZurN7drdpl4a8t73Z45nZMSksJSe5xWaz93zLjDs6ezs/veud/j/l33Rz2YMFpfn/B16p6oi+k+uwr37C6q7aIKlo0xM6Pc3wbgcUKCZWA+8IIx5kMAEXkCmAKEBcudhTMatS1nW0mSxILiBUEzKrSF3w/E2oq17GjZwdaDW6nfVe/ZZXn3zLt55K1HwtInYi05IZkbp0S+aMPJcgZetHX+1KZFTZ5zX2emZAbyMOMhOSGZ5JTgrj2vlqfhOcM75HhEJKZXtnJOzGId4CQmJDLzjOCvnkjTNbbH8jOX8/Khl2O6z/ZITEgMGoDrHtzW1pxjsMo4dJ7k1oSmiU0eOLnVll4RoTinmBmDZ7DxrY1Rz8YQyv0ZiibHsbNp69SVBZkFNC9r5ssNX6bpz/654e2VmpjK3KFzw3r6uoq89DyuOzv2aSWlA0rJSM7gw2Mfxnzfoe6ruq9LnvQpb7GYDaPYGPOW/XAe8LrHZu8B/yYiq7HaXyuAH3ps12msnLSSgswC33xULyLSpnysUM6o38vGBF+QIatXFpUFlVQWVPLNs71zhkv6lrBq0qpAK8LJtm7H02VjLqOgT0FUOaVu7pSKS0ZeEjQoprNYMX5FVHN5d3ZeOXud9TKlkThX4Opoa6at4bF3Wh9UFk9JCUncMPmGqNIipuVP49Wlr7Y7MHPmsY1mppKOdHXp1W2+CE1bfH7o52n6c1PQ9KKxsPWSrZ7LkxOSOfbZsZi+Vldz76x72fynzZ69kLEUaSpH1fXISefXimwESrCmjnsX+LIxZr+IlNn3l4tIIvAjYBrWkJPfG2O+0dq+y8rKzLZt207q+DqjiRuseW/dFwqIFWNMYFqxWF2oQ6lIXml5hbon6mhY2BAxJ84tHp9TZzaM7lwvDh89TN0Tdaybvo6i7KLWnxCFjnrfjnx8JKoZRFT7vX3kbV5pecV3ikelejIRedkYU+a17qRblo0xnolaxphtwHL7/qdA+EXRe6hYDQpSqjMoHVDaJQLQhcMXWvMHd2PZqdkndTnteNJA+dQryioKu4CFUqp1MZkNQ3UeXbErXKmOcNOU6C9Jq05IlEQ+NZ/G+zCUUipuNFjuhibmTWTxSO8rnCmlVFtsnLuRbQe7XzqcUkpFS4PlbujeWffG+xCUUt3E0OyhnhejUUqpnqLrzSmjlFJKKaVUB9FgWSkVN16XD1dKKaU6E03DUEp1OBHhurLrOPf0c+N9KEoppVREGiwrpeJi2ejwC5sopZRSnY2mYSillFJKKeVDg2WllFJKKaV8aLCslFJKKaWUDw2WlVJKKaWU8qHBslJKKaWUUj40WFZKKaWUUsqHBstKKaWUUkr50GBZKaWUUkopH2KMifcx+BKRvwDvxuGl+wF/jcPrqo6l5dwzaDl3f1rGPYOWc88Qr3I+wxjT32tFpw6W40VEthljyuJ9HOrU0nLuGbScuz8t455By7ln6IzlrGkYSimllFJK+dBgWSmllFJKKR8aLHtbH+8DUB1Cy7ln0HLu/rSMewYt556h05Wz5iwrpZRSSinlQ1uWlVJKKaWU8qHBslJKKaWUUj40WA4hIlUi8oaI7BGRlfE+HhWZiBSISKOI7BKRP4rICnt5XxFpEJG37L859nIRkTvs8t0pIuNd+1pmb/+WiCxzLZ8gIs32c+4QEen4/1SJSKKI7BCR39mPh4jIi3a5PCQiKfbyXvbjPfb6Qtc+VtnL3xCRWa7lWu87ARHJFpGHReR1EdktIlO0Lnc/IvJ1+/v6NRH5lYikan3u+kTkZyLSIiKvuZad8vrr9xoxZYzRm30DEoE/AUVACvAqMCrex6W3iGU2EBhv3+8DvAmMAm4FVtrLVwI/sO9fADwBCDAZeNFe3hd42/6bY9/Psde9ZG8r9nNnx/v/7ok34BvAA8Dv7Me/Bi62798NXGnf/wpwt33/YuAh+/4ou073AobYdT1R633nuQG/AJbb91OAbK3L3esGnA68A/S2H/8auFTrc9e/AdOA8cBrrmWnvP76vUYsb9qyHGwisMcY87Yx5hPgQWBenI9JRWCMOWCM2W7f/wewG+vLeB7WDy/232r7/jyg3lheALJFZCAwC2gwxnxgjPkb0ABU2esyjTEvGKsm1rv2pTqIiOQDFwI/tR8LMAN42N4ktIydsn8YOM/efh7woDHmY2PMO8AerDqv9b4TEJEsrB/bewGMMZ8YYw6jdbk7SgJ6i0gSkAYcQOtzl2eM+W/gg5DFHVF//V4jZjRYDnY6sNf1eJ+9THUBdvfcOOBFINcYc8BedRDIte/7lXGk5fs8lquO9UPgW8Bn9uPTgMPGmOP2Y3e5BMrSXn/E3r6tZa861hDgL8DP7XSbn4pIOlqXuxVjzH7gNuA9rCD5CPAyWp+7q46ov36vETMaLKtuQUQygI3ANcaYv7vX2WehOkdiFyUic4AWY8zL8T4WdUolYXXh/tgYMw74J1aXaoDW5a7Pziedh3VyNAhIB6rielCqQ3RE/T1Vr6HBcrD9QIHrcb69THViIpKMFShvMMY8Yi8+ZHfbYP9tsZf7lXGk5fkey1XHOQeYKyL/h9WlOgNYh9Vtl2Rv4y6XQFna67OA92l72auOtQ/YZ4x50X78MFbwrHW5e5kJvGOM+Ysx5hjwCFYd1/rcPXVE/fV7jZjRYDnYVqDYHpWbgjWYYHOcj0lFYOeu3QvsNsbc7lq1GXBG0S4DNrmWL7VH4k4GjtjdN08C54tIjt3ycT7wpL3u7yIy2X6tpa59qQ5gjFlljMk3xhRi1clnjTFLgEZgob1ZaBk7Zb/Q3t7Yyy+2R9cPAYqxBoxove8EjDEHgb0iUmIvOg/Yhdbl7uY9YLKIpNnl4JSz1ufuqSPqr99rxE6sRwx29RvWCM03sUbTXh/v49Fbq+V1LlaXy07gFft2AVZO2zPAW8DTQF97ewH+yy7fZqDMta8vYg0S2QNc5lpeBrxmP+cu7Ctf6i0u5V3JidkwirB+HPcAvwF62ctT7cd77PVFrudfb5fjG7hmQtB63zluQCmwza7Pj2KNhte63M1uwL8Dr9tl8UusGS20PnfxG/ArrDz0Y1g9RV/qiPrr9xqxvOnlrpVSSimllPKhaRhKKaWUUkr50GBZKaWUUkopHxosK6WUUkop5UODZaWUUkoppXxosKyUUkoppZQPDZaVUkoppZTyocGyUkoppZRSPv4f1v7sBTLw0zkAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 864x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# MLP3_no_lr_decay_vars = (lossi, ud, layers, parameters, x)\n",
    "no_decay_params = MLP3_no_lr_decay_vars[3]\n",
    "no_decay_updates = MLP3_no_lr_decay_vars[1]\n",
    "plot_update_to_data_ratio(no_decay_params, no_decay_updates)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e92bcfe",
   "metadata": {},
   "source": [
    "**Comment:** As anticipidated, the learning rate decay was not needed. We now have a uniform update ratio dsitribution that lies on the black line which we want."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6cb15c5",
   "metadata": {},
   "source": [
    "---\n",
    "<a id=\"201\"></a>\n",
    "## 2.1.  Testing: With BatchNorm\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 263,
   "id": "9a96189a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# MLP3_no_lr_decay_vars = (lossi, ud, layers, parameters, x)\n",
    "no_decay_layers = MLP3_no_lr_decay_vars[2]\n",
    "no_decay_logits = MLP3_no_lr_decay_vars[4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 264,
   "id": "95b25a86",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train loss: 2.1539957523345947\n",
      "dev loss: 2.17282772064209\n",
      "test loss: 2.1736271381378174\n"
     ]
    }
   ],
   "source": [
    "@torch.no_grad() # this decorator disables gradient tracking\n",
    "def split_loss(split):\n",
    "    x,y = {\n",
    "        \"train\": (Xtr, Ytr),\n",
    "        \"dev\": (Xdev, Ydev),\n",
    "        \"test\": (Xte, Yte),\n",
    "    }[split]\n",
    "    \n",
    "    emb = C[x] # (N, block_size, n_embd)\n",
    "    x = emb.view(emb.shape[0], -1) # concat into (N, block_size * n_embd)\n",
    "    for layer in no_decay_layers:\n",
    "        x = layer(x)\n",
    "    loss = F.cross_entropy(x, y)\n",
    "    \n",
    "    print(f\"{split} loss: {loss.item()}\")\n",
    "\n",
    "# put layers into eval mode\n",
    "for layer in no_decay_layers:\n",
    "    layer.training = False\n",
    "split_loss('train')\n",
    "split_loss('dev')\n",
    "split_loss('test')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "387a16d8",
   "metadata": {},
   "source": [
    "---\n",
    "<a id=\"202\"></a>\n",
    "## 2.2.  Testing: Fold BatchNorm (`gamma`, `beta`) into Preceding Linear Layer (`W`, `b`)\n",
    "---\n",
    "\n",
    "BatchNorm can be folded into the preceding linear layer because its scaling and shifting operations can be absorbed into the weights and biases of the linear layer. Specifically, the **scaling factor (`gamma`) can be multiplied with the weights**, and the **shifting factor (`beta`) can be added to the biases**, effectively eliminating the need for a separate BatchNorm layer. This is possible because the `BatchNorm` layer only performs a ***linear transformation, which can be combined with the linear transformation of the preceding layer.*** By folding BatchNorm into the linear layer, we can simplify the network architecture and reduce computational overhead during inference.\n",
    "It consists of two steps:\n",
    "\n",
    "    1- normalizing the batch by subtracting its mean and dividing it by its standard deviation.\n",
    "    2- scaling and shifting it by two learnable parameters called gamma and beta.\n",
    "\n",
    "However, at inference time, BatchNorm is **not necessary** and can be removed to speed up the network.\n",
    "\n",
    "One way to remove BatchNorm is to fold it into the preceding linear layer, which is also a `linear transformation`.\n",
    "\n",
    "This means that we can combine the `weights` and `biases` of the **linear** **layer** with the `gamma` and `beta` of the **BatchNorm layer** to get a new linear layer that has the same output as the original one.\n",
    "\n",
    "Rearrangement of the:\n",
    "\n",
    "$$\n",
    "y = \\text{Linear}(x) = Wx + b\n",
    "$$\n",
    "\n",
    "$$\n",
    "z = \\text{BatchNorm}(y) = \\gamma \\frac{y - \\mu}{\\sigma} + \\beta\n",
    "$$\n",
    "\n",
    "$$\n",
    "z = \\text{BatchNorm}(\\text{Linear}(x)) = \\gamma \\frac{Wx + b - \\mu}{\\sigma} + \\beta\n",
    "$$\n",
    "\n",
    "$$\n",
    "z = (\\frac{\\gamma}{\\sigma})Wx + (\\frac{\\gamma}{\\sigma})(b - \\mu) + \\beta\n",
    "$$\n",
    "\n",
    "$$\n",
    "z = W_2 x + b_2\n",
    "$$\n",
    "\n",
    "where $$W_2 = (\\frac{\\gamma}{\\sigma})W, \\quad b_2 = (\\frac{\\gamma}{\\sigma})(b - \\mu) + \\beta$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 265,
   "id": "d1022ea9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Linear\n",
      "BatchNorm1d\n",
      "Tanh\n",
      "Linear\n",
      "BatchNorm1d\n",
      "Tanh\n",
      "Linear\n",
      "BatchNorm1d\n"
     ]
    }
   ],
   "source": [
    "for layer in no_decay_layers:\n",
    "    print(layer.__class__.__name__)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad7c39cd",
   "metadata": {},
   "source": [
    "Let's combine the parameters for layers $0$ and $1$, $3$ and $4$, & $6$ and $7$. Updating the `Linear` layers parameters (`W` and `b`) leveraging linear transformation will get the job done. We also will disable gradient checking. In essence we go from 8 layers with some as `BatchNorm1d` to 5 layers with no `BatchNorm1d` layer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 266,
   "id": "10912f6f",
   "metadata": {},
   "outputs": [],
   "source": [
    "with torch.no_grad():\n",
    "    layers[0].weight *= (layers[1].gamma / torch.sqrt(layers[1].running_var))\n",
    "    layers[3].weight *= (layers[4].gamma / torch.sqrt(layers[4].running_var))\n",
    "    layers[6].weight *= (layers[7].gamma / torch.sqrt(layers[7].running_var))\n",
    "    layers[0].bias = - ((layers[1].gamma * layers[1].running_mean) / torch.sqrt(layers[1].running_var)) + layers[1].beta\n",
    "    layers[3].bias = - ((layers[4].gamma * layers[4].running_mean) / torch.sqrt(layers[4].running_var)) + layers[4].beta\n",
    "    layers[6].bias = - ((layers[7].gamma * layers[7].running_mean) / torch.sqrt(layers[7].running_var)) + layers[7].beta\n",
    "     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 267,
   "id": "b2e038e7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Linear\n",
      "Tanh\n",
      "Linear\n",
      "Tanh\n",
      "Linear\n"
     ]
    }
   ],
   "source": [
    "new_layers = []\n",
    "\n",
    "for layer in layers:\n",
    "    if not isinstance(layer, BatchNorm1d):\n",
    "        new_layers.append(layer)\n",
    "\n",
    "for layer in new_layers:\n",
    "    print(layer.__class__.__name__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 268,
   "id": "8cf9661c",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train loss: 2.1539957523345947\n",
      "dev loss: 2.17282772064209\n",
      "test loss: 2.1736271381378174\n"
     ]
    }
   ],
   "source": [
    "@torch.no_grad() # this decorator disables gradient tracking\n",
    "def split_loss(split):\n",
    "    x,y = {\n",
    "        \"train\": (Xtr, Ytr),\n",
    "        \"dev\": (Xdev, Ydev),\n",
    "        \"test\": (Xte, Yte),\n",
    "    }[split]\n",
    "    \n",
    "    emb = C[x] # (N, block_size, n_embd)\n",
    "    x = emb.view(emb.shape[0], -1) # concat into (N, block_size * n_embd)\n",
    "    for new_layer in new_layers:\n",
    "        x = new_layer(x)\n",
    "    loss = F.cross_entropy(x, y)\n",
    "    \n",
    "    print(f\"{split} loss: {loss.item()}\")\n",
    "\n",
    "# put layers into eval mode\n",
    "for layer in new_layers:\n",
    "    layer.training = False\n",
    "split_loss('train')\n",
    "split_loss('dev')  \n",
    "split_loss('test')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67f8811e",
   "metadata": {},
   "source": [
    "**Comment:** The losses for both cases (batchNorm, no batchNorm) are the same !!!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "535e031e",
   "metadata": {},
   "source": [
    "## ASIDE: Pythonic checks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 269,
   "id": "c791a965",
   "metadata": {},
   "outputs": [],
   "source": [
    "_a_tests22 = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 270,
   "id": "d5393b5c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "batchnorm YAY\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'batch'"
      ]
     },
     "execution_count": 270,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "if _a_tests22:\n",
    "    print(\"batchnorm YAY\")\n",
    "    case = 'batch'\n",
    "if not _a_tests22:\n",
    "    print(\"no batchnorm :((((((\")\n",
    "    case = 'no batch'\n",
    "    \n",
    "case"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 271,
   "id": "0bb7a915",
   "metadata": {},
   "outputs": [],
   "source": [
    "def _B_fn(case):\n",
    "    return case"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 272,
   "id": "c7865cf7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'batch'"
      ]
     },
     "execution_count": 272,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_B_fn(case)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 273,
   "id": "b27b7a66",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "10000\n",
      "20000\n",
      "30000\n",
      "40000\n",
      "50000\n",
      "60000\n",
      "70000\n",
      "80000\n",
      "90000\n"
     ]
    }
   ],
   "source": [
    "alpha = 100000\n",
    "for i in range(alpha):\n",
    "    if i % (alpha/10) == 0:\n",
    "        print(i)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}