From 4e3b0c37fc3f4f76d57ce3147d6190e8589d1db6 Mon Sep 17 00:00:00 2001 From: wassname Date: Sun, 10 Dec 2023 12:31:49 +0800 Subject: [PATCH] VAE exp --- README.md | 8 + mjc_notes.md | 118 + notebooks/033_train_cvae.ipynb | 3018 ++++++++++++++++++----- src/datasets/batch.py | 98 +- src/datasets/dm.py | 5 +- src/datasets/hs.py | 358 +-- src/datasets/intervene.py | 1 + src/probes/pl_ranking.py | 3 +- src/repe/rep_control_pipeline_baukit.py | 3 +- src/repe/rep_reading_pipeline.py | 1 + 10 files changed, 2786 insertions(+), 827 deletions(-) diff --git a/README.md b/README.md index da60858..944996c 100644 --- a/README.md +++ b/README.md @@ -71,7 +71,15 @@ pred_last_choice_is_true = y / (y_pred2-y_pred) pred_last_choice_is_true # [1, -1] ``` + +# Running + +```sh +python notebooks/make_dataset2.py --max_examples 1720 220 --datasets imdb glue:qnli super_glue:boolq +``` + # Description + There is some previous work on this ([ELK](https://github.com/EleutherAI/elk), [DLK](https://github.com/collin-burns/discovering_latent_knowledge/blob/main/CCS.ipynb), CSS, etc) that all take varias approaches. They have this in common: - Show the model 2 statements “the sky is blue” “the sky is green” diff --git a/mjc_notes.md b/mjc_notes.md index f2b813a..9856bc7 100644 --- a/mjc_notes.md +++ b/mjc_notes.md @@ -1971,3 +1971,121 @@ https://colab.research.google.com/drive/1rPy82rL3iZzy2_Rd3F82RwFhlVnnroIh?usp=sh n_instances - remove this, another batch dim + + +- nice timeseries 1d VAE from merlion https://github.dev/salesforce/Merlion/blob/01c3fc3406ebf19798cedcddbe829ae5339e1424/merlion/models/anomaly/vae.py#L186 +- simple one https://github.com/ctallec/world-models/blob/master/models/vae.py +- neels https://github.dev/neelnanda-io/1L-Sparse-Autoencoder/blob/bcae01328a2f41d24bd4a9160828f2fc22737f75/utils.py#L106 + + +# 2023-12-08 10:01:13 + +Initial obs +- it can still overfit on the latent state, hmmm! Well maybe I need to make it very small or space or quantized (dreamer style) +- a tanh seems to help!... just in the mse one it makes it worse... hmm. + + +oh CVAE generalizes well notebooks/033_train_cvae.ipynb + test/acc 0.6785010099411011 │ 0.7179487347602844 + llm gave did didn't +instructed to +tell a truth 0.74 NaN +tell a lie 0.91 0.54 + oos/acc │ 0.7257769703865051 │ 0.7664233446121216 │ 0.7627736926078796 +llm gave did didn't +instructed to +tell a truth 0.78 NaN +tell a lie 1.00 0.66 + +# 2023-12-08 15:44:03 + +Questions: + - [ ] hmm in the anthorpic [paper](https://transformer-circuits.pub/2022/toy_model/index.html#demonstrating-setup-loss) they weight by feature importance, this seems important + - [x] anything else I need to know from the sparse transformer AE's? + - [x] what is dictionary learning? it seems to just be a huge 1 layer sparse autoencoder. no categorical latent or anything + - they seem to use weight norm on decoder, not tie weights. have 8 times the latent space compared to activations + - oh they replace activations with reconstructed + - oh actual training [tips](https://docs.google.com/document/u/0/d/187jfZSbhRjjQaazjYlThBsKp3Q0Pw3VdIHVST9H2dvw/mobilebasic) + - what's the decoder weight norm?? + - [x] do I need something special to make it sparse? no it looks like it's just the l1 loss + - [ ] + - [ ] what where the dreamer learnings? + - two-hot latent space?? I guess that means it turns into [2, 1, 0, 1]. I'm assuming neg vs pos? + - symlog scaling for rewards prediction - I probobly don't need this + - how do the discrete states work? https://github.dev/Eclectic-Sheep/sheeprl/blob/52f49be5971c5753e18bdf328d3035334fe688f1/sheeprl/algos/dreamer_v3/agent.py#L31 + - [ ] does my pcr probe work ok? how to debug? + + +> Features Vary in Importance: Not all features are equally useful to a given task. Some can reduce the loss more than others. For an ImageNet model, where classifying different species of dogs is a central task, a floppy ear detector might be one of the most important features it can have. In contrast, another feature might only very slightly improve performance + + +IRIS loss https://github.dev/eloialonso/iris/blob/ac6be401fed2b6176c9ce0cf1dc10e376c9d740d/src/models/tokenizer/tokenizer.py#L50-L55 + + # Codebook loss. Notes: + # - beta position is different from taming and identical to original VQVAE paper + # - VQVAE uses 0.25 by default + beta = 1.0 + commitment_loss = (z.detach() - z_quantized).pow(2).mean() + beta * (z - z_quantized.detach()).pow(2).mean() + reconstruction_loss = torch.abs(observations - reconstructions).mean() + perceptual_loss = torch.mean(self.lpips(observations, reconstructions)) + + +https://openreview.net/pdf?id=o8IDoZggqO +> We follow DreamerV3 in using discrete regression with two-hot targets and symlog scaling for rewards prediction (Bellemare et al., 2017; Imani & White,2018). + + + +> SqrtTransform Using two-hot discrete regression with the asymmetric square root transformation intro- duced by R2D221 and used in MuZero34 +https://arxiv.org/pdf/2301.04104v1.pdf +- R2D2 https://openreview.net/forum?id=r1lyTjAqYX + +> The representations are sampled from a vector of softmax distributions and we take straight-through gradients through the sampling step +- "sampled from a vector of softmax distributions"? I would like to see psudocode. I guess it just uses the distributions baked into torch fd.MultivariateNormalDiag(mean, std) +> To train the critic, we symlog transform the targets Rλ t and then twohot encode them into a soft label for the softmax distribution produced by the critic. Twohot encoding is a generalization of onehot encoding to continuous values. It produces a vector of length |B| where all elements are 0 except for the two entries closest to the encoded continuous number, at positions k and k + 1. These two entries sum up to 1, with more weight given to the entry that is closer to the enco + + +https://arxiv.org/pdf/2301.04104v1.pdf + +> the world model encodes sensory inputs into a discrete representation zt t + +cal.s.mcdougall@gmail.com + +dictionary learning + +- experiment I added amazon, and it doubled the training data, lets see if I get above 80% acc... I was getting ~75% + + +https://www.alignmentforum.org/posts/F4iogK5xdNd7jDNyw/comparing-anthropic-s-dictionary-learning-to-ours +> Size of training set: We trained our autoencoders for 10M tokens. Anthropic trained theirs for much longer, 8B tokens. +Wow that's a lot. If I want to focus on just lying, I might need to focus on not reconstruction the whole state... + + +## Best dreamer v3 repo? + + +- https://github.dev/kc-ml2/SimpleDreamer oh it's dreamer 1 meh +- https://github.dev/Eclectic-Sheep/sheeprl/blob/52f49be5971c5753e18bdf328d3035334fe688f1/sheeprl/algos/dreamer_v3/agent.py#L31 + + + symlog is simple `torch.sign(x) * torch.log(1 + torch.abs(x))` + +# 2023-12-09 11:34:11 + +Questions: +- understand HALOs https://twitter.com/ethayarajh/status/1732837520784957476 https://github.com/ContextualAI/HALOs + - so it's just DPO with a differen't activation function on the reward, and notably it can use reward text instead of ranked pairs, letting you skip SFT. In a way it's just SFT? + - [ ] discrete states, just look up QVAE? + - [ ] hmm some use a categorical, and the gumbel reparam trick for end to end backprop + - [ ] some use VQ-VAE which I haven't looked at before but look promising. But I want to! + - [ ] does my pcr probe work ok? how to debug? I guess I need to check acc from it for a start + - [ ] does my conv vae work? maybe I need transposed conv blocks? + - perhaps just use https://github.com/ctallec/world-models/blob/master/models/vae.py#L10 + - perhaps I need to focus on important features? Or on a task? + - e.g. if doing inference on the reconstructed parts, can I get the same output? (RAM heavy) + - if just apply an importance multipier + + + +```py +QVAE psuedocode +``` diff --git a/notebooks/033_train_cvae.ipynb b/notebooks/033_train_cvae.ipynb index 043b5ee..48d0ff3 100644 --- a/notebooks/033_train_cvae.ipynb +++ b/notebooks/033_train_cvae.ipynb @@ -994,6 +994,11 @@ "# Params" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, { "cell_type": "code", "execution_count": null, @@ -1010,10 +1015,10 @@ "# params\n", "batch_size = 32*2\n", "lr = 1e-3\n", - "wd = 1e-64\n", - "max_rows = 40000\n", + "wd = 1e-5\n", + "max_rows = 80000\n", "\n", - "max_epochs = 200\n", + "max_epochs = 50\n", "device = 'cuda'\n", "\n", "# quiet please\n", @@ -1155,232 +1160,6 @@ "ds2\n" ] }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [], - "source": [ - "import einops\n", - "from jaxtyping import Float, Int\n", - "from typing import Optional, Callable, Union, List, Tuple\n", - "from src.probes.pl_ranking import InceptionBlock, LinBnDrop, ConvBlock\n", - "\n", - "\n", - "# class Encoder(nn.Module):\n", - "# def __init__(self, c_in, hs, c_out, ks=[7, 5, 3]):\n", - "# super().__init__()\n", - "# n_layers, n_channels = c_in\n", - "\n", - "# self.conv = nn.Sequential(\n", - "# InceptionBlock(n_channels, hs, ks=ks),\n", - "# InceptionBlock(hs*4, hs, ks=ks),\n", - "# InceptionBlock(hs*4, hs, ks=ks),\n", - "# InceptionBlock(hs*4, hs, ks=ks),\n", - "# )\n", - "\n", - "# self.fc = nn.Sequential(\n", - "# nn.Linear(hs*4*n_layers, c_out),\n", - "# nn.ReLU(),\n", - "# nn.Linear(c_out, c_out),\n", - "# )\n", - "\n", - "# def forward(self, x):\n", - "# x = self.conv(x)\n", - "# x = rearrange(x, 'b l c -> b (l c)')\n", - "# x = self.fc(x)\n", - "# return x\n", - "\n", - "# class Decoder(nn.Module):\n", - "# def __init__(self, c_in, layers, hs, c_out, ks=[7, 5, 3]):\n", - "# super().__init__()\n", - "# n_latent = c_in\n", - "\n", - "# self.fc = nn.Sequential(\n", - "# nn.Linear(n_latent, hs*layers),\n", - "# nn.ReLU(),\n", - "# nn.Linear(hs*layers, hs*layers),\n", - "# nn.ReLU(),\n", - "# )\n", - "\n", - "# self.conv = nn.Sequential(\n", - "# InceptionBlock(hs, hs, ks=ks),\n", - "# InceptionBlock(hs*4, hs, ks=ks),\n", - "# InceptionBlock(hs*4, hs, ks=ks),\n", - "# nn.Conv1d(hs*4, hs, 1),\n", - "# )\n", - "\n", - "\n", - "# def forward(self, x):\n", - "# layers = x.shape[1]\n", - "# x = rearrange(x, 'b l c -> b (l c)')\n", - "# x = self.fc(x)\n", - "# x = rearrange(x, 'b (l c) -> b l c', l=layers)\n", - "# x = self.conv(x)\n", - "# return x\n", - " \n", - "\n", - "def make_encoder(c_in, depth, hs, c_out, ks=[7, 5, 3], encoder=True):\n", - " if encoder:\n", - " layers = [nn.BatchNorm1d(c_in[1], affine=False)]\n", - " else:\n", - " layers = []\n", - " for i in range(depth+1):\n", - " if i==0: # first layer\n", - " if depth==0:\n", - " layers.append(InceptionBlock(c_in[1], 1, ks=ks))\n", - " else:\n", - " layers.append(InceptionBlock(c_in[1], hs, ks=ks))\n", - " elif (i>0) and (i0) and (i b h l')\n", - " # if not self._ae_mode:\n", - " # with torch.no_grad():\n", - " # l1_loss, l2_loss, loss, latent, h_rec = self.ae(x)\n", - " # else:\n", - " l1_loss, l2_loss, loss, latent, h_rec = self.ae(x)\n", - " \n", - " latent2 = rearrange(latent, 'b l h -> b (l h)')\n", - " pred = self.head(latent2).squeeze(1)\n", - " return dict(pred=pred, l1_loss=l1_loss, l2_loss=l2_loss, loss=loss, latent=latent, h_rec=h_rec)\n", - " \n", - " \n", - " def _step(self, batch, batch_idx, stage='train'):\n", - "\n", - " # if stage=='train':\n", - " # # Normalize the decoder weights before each optimization step (from https://colab.research.google.com/drive/1rPy82rL3iZzy2_Rd3F82RwFhlVnnroIh?usp=sharing#scrollTo=q1JctT2Pvw-r)\n", - " # # Presumably this is a way to implement weight norm to regularize the decoder\n", - " # self.normalize_decoder()\n", - "\n", - "\n", - " x0, x1, y = batch\n", - " info0 = self(x0)\n", - " info1 = self(x1)\n", - " ypred1 = info1['pred']\n", - " ypred0 = info0['pred']\n", - "\n", - "\n", - " if stage=='pred':\n", - " return (ypred1-ypred0).float()\n", - " \n", - " \n", - " \n", - " pred_loss = F.smooth_l1_loss(ypred1-ypred0, y)\n", - " rec_loss = info0['loss'] + info1['loss']\n", - " l1_loss = (info0['l1_loss'] + info1['l1_loss']).mean()\n", - " l2_loss = (info0['l2_loss'] + info1['l2_loss']).mean()\n", - " \n", - " y_cls = ypred1>ypred0 # switch2bool(ypred1-ypred0)\n", - " self.log(f\"{stage}/acc\", accuracy(y_cls, y>0, \"binary\"), on_epoch=True, on_step=False)\n", - " self.log(f\"{stage}/loss_pred\", float(pred_loss), on_epoch=True, on_step=False, prog_bar=True)\n", - " self.log(f\"{stage}/loss_rec\", float(rec_loss), on_epoch=True, on_step=False, prog_bar=True)\n", - " self.log(f\"{stage}/l1_loss\", l1_loss, on_epoch=True, on_step=False)\n", - " self.log(f\"{stage}/l2_loss\", l2_loss, on_epoch=True, on_step=False)\n", - " self.log(f\"{stage}/n\", float(len(y)), on_epoch=True, on_step=False, reduce_fx=torch.sum)\n", - " if self._ae_mode:\n", - " return rec_loss\n", - " else:\n", - " return pred_loss\n", - "\n" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -1390,7 +1169,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 22, "metadata": {}, "outputs": [], "source": [ @@ -1402,7 +1181,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 23, "metadata": {}, "outputs": [ { @@ -1450,6 +1229,212 @@ "dl_oos, dm_oos = get_out_of_sample_dl(fs_oos, dm)\n" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Model" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "import einops\n", + "from jaxtyping import Float, Int\n", + "from typing import Optional, Callable, Union, List, Tuple\n", + "\n", + "from torch import dropout\n", + "from src.probes.pl_ranking import InceptionBlock, LinBnDrop, ConvBlock\n", + "\n", + "\n", + "class Encoder(nn.Module):\n", + " def __init__(self, n_layers, n_channels, hs, c_out, ks=[7, 5, 3], dropout=0):\n", + " super().__init__()\n", + " self.n_layers = n_layers\n", + "\n", + " self.conv = nn.Sequential(\n", + " nn.BatchNorm1d(n_channels),\n", + " InceptionBlock(n_channels, hs, ks=ks, coord=True, conv_dropout=dropout),\n", + " InceptionBlock(hs*4, hs, ks=ks, coord=True, conv_dropout=dropout),\n", + " # InceptionBlock(hs*4, hs, ks=ks, coord=True, conv_dropout=dropout),\n", + " InceptionBlock(hs*4, hs, ks=ks, coord=True, conv_dropout=dropout),\n", + " InceptionBlock(hs*4, hs, ks=ks),\n", + " )\n", + "\n", + " self.fc = nn.Sequential(\n", + " LinBnDrop(hs*4*n_layers, c_out*n_layers, dropout=dropout),\n", + " nn.Linear(c_out*n_layers, c_out*n_layers),\n", + " )\n", + "\n", + " def forward(self, x):\n", + " x = self.conv(x)\n", + " x = rearrange(x, 'b c l -> b (c l)')\n", + " x = self.fc(x)\n", + " x = rearrange(x, 'b (c l) -> b c l', l=self.n_layers)\n", + " return x\n", + "\n", + "class Decoder(nn.Module):\n", + " def __init__(self, n_latent, n_layers, hs, c_out=1, ks=[7, 5, 3], dropout=0):\n", + " super().__init__()\n", + " self.layers = n_layers\n", + "\n", + " self.fc = nn.Sequential(\n", + " nn.BatchNorm1d(n_latent*n_layers),\n", + " LinBnDrop(n_latent*n_layers, hs*n_layers, dropout=dropout),\n", + " nn.ReLU(),\n", + " )\n", + "\n", + " self.conv = nn.Sequential(\n", + " InceptionBlock(hs, hs, ks=ks, coord=True, conv_dropout=dropout),\n", + " InceptionBlock(hs*4, hs, ks=ks, conv_dropout=dropout),\n", + " # InceptionBlock(hs*4, hs, ks=ks, coord=True),\n", + " nn.Conv1d(hs*4, c_out, 1),\n", + " )\n", + "\n", + "\n", + " def forward(self, x):\n", + " x = rearrange(x, 'b l c -> b (l c)')\n", + " x = self.fc(x)\n", + " x = rearrange(x, 'b (c l) -> b c l', l=self.layers)\n", + " x = self.conv(x)\n", + " return x\n", + "\n", + "\n", + "class AutoEncoder(nn.Module):\n", + "\n", + " def __init__(self, c_in, depth=3, n_hidden=32, n_latent=32, l1_coeff: float = 1.0, dropout=0):\n", + " super().__init__()\n", + " self.l1_coeff = l1_coeff\n", + " n_layers, n_channels = c_in\n", + " self.enc = Encoder(n_layers, n_channels, n_hidden, n_latent, dropout=dropout)\n", + " self.dec = Decoder(n_latent, n_layers, n_hidden//4, c_out=n_channels, dropout=dropout)\n", + " self.apply_weight_norm(self.dec)\n", + " self.apply_weight_norm(self.enc)\n", + " \n", + " def apply_weight_norm(self, net):\n", + " for m in net.modules():\n", + " if isinstance(m, nn.Conv1d):\n", + " # I think it's 1. In the example they use 2, but their weights are transposed before use\n", + " torch.nn.utils.parametrizations.weight_norm(m, dim=1)\n", + "\n", + " def forward(self, h: Float[Tensor, \"batch_size n_hidden n_channels\"]):\n", + " latent = self.enc(h)\n", + " h_rec = self.dec(latent)\n", + "\n", + " # Compute loss, return values\n", + " l2_loss = (h_rec - h).pow(2).mean(-1).sum(1) # shape [batch_size sum(neurons) mean(layers)] - punish the model for not reconstructing the input\n", + " l1_loss = latent.abs().sum(-1).sum(1) # shape [batch_size sum(latent) sum(layers)] - punish the model for large latent values\n", + " loss = (self.l1_coeff * l1_loss + l2_loss).mean(0) # scalar\n", + "\n", + " return l1_loss, l2_loss, loss, latent, h_rec\n", + " \n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "https://colab.research.google.com/drive/1rPy82rL3iZzy2_Rd3F82RwFhlVnnroIh?usp=sharing#scrollTo=2MD88v4Zvw-r\n" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "def freeze(model, mode: bool= False):\n", + " print(f'requires_grad: {mode}, {model}')\n", + " for param in model.parameters():\n", + " param.requires_grad = mode\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "class PLAE(PLRankingBase):\n", + " def __init__(self, c_in, total_steps, depth=0, lr=4e-3, weight_decay=1e-9, hs=64, n_latent=32, l1_coeff=1, dropout=0,**kwargs):\n", + " super().__init__(total_steps=total_steps, lr=lr, weight_decay=weight_decay)\n", + " self.save_hyperparameters()\n", + "\n", + " self.ae = AutoEncoder(c_in, n_hidden=hs, n_latent=n_latent, depth=depth, l1_coeff=l1_coeff, dropout=dropout)\n", + " n_layers, n_channels = c_in\n", + " n = n_latent * n_layers\n", + " self.head = nn.Sequential( \n", + " LinBnDrop(n, n//4, dropout=dropout),\n", + " LinBnDrop(n//4, n//12, dropout=dropout),\n", + " nn.Linear(n//12, 1), \n", + " # nn.Tanh(),\n", + " )\n", + " self._ae_mode = True\n", + "\n", + " def ae_mode(self, mode=0):\n", + " self._ae_mode = mode\n", + " freeze(self.ae, mode in [0, 2])\n", + " \n", + " def forward(self, x):\n", + " if x.ndim==4:\n", + " x = x.squeeze(3)\n", + " x = rearrange(x, 'b l h -> b h l')\n", + " # if not self._ae_mode:\n", + " # with torch.no_grad():\n", + " # l1_loss, l2_loss, loss, latent, h_rec = self.ae(x)\n", + " # else:\n", + " l1_loss, l2_loss, loss, latent, h_rec = self.ae(x)\n", + " \n", + " latent2 = rearrange(latent, 'b l h -> b (l h)')\n", + " pred = self.head(latent2).squeeze(1)\n", + " return dict(pred=pred, l1_loss=l1_loss, l2_loss=l2_loss, loss=loss, latent=latent, h_rec=h_rec)\n", + " \n", + " \n", + " def _step(self, batch, batch_idx, stage='train'):\n", + "\n", + " # if stage=='train':\n", + " # # Normalize the decoder weights before each optimization step (from https://colab.research.google.com/drive/1rPy82rL3iZzy2_Rd3F82RwFhlVnnroIh?usp=sharing#scrollTo=q1JctT2Pvw-r)\n", + " # # Presumably this is a way to implement weight norm to regularize the decoder\n", + " # self.normalize_decoder()\n", + "\n", + "\n", + " x0, x1, y = batch\n", + " info0 = self(x0)\n", + " info1 = self(x1)\n", + " ypred1 = info1['pred']\n", + " ypred0 = info0['pred']\n", + "\n", + "\n", + " if stage=='pred':\n", + " return (ypred1-ypred0).float()\n", + " \n", + " \n", + " \n", + " pred_loss = F.smooth_l1_loss(ypred1-ypred0, y)\n", + " rec_loss = info0['loss'] + info1['loss']\n", + " l1_loss = (info0['l1_loss'] + info1['l1_loss']).mean()\n", + " l2_loss = (info0['l2_loss'] + info1['l2_loss']).mean()\n", + " \n", + " y_cls = ypred1>ypred0 # switch2bool(ypred1-ypred0)\n", + " self.log(f\"{stage}/acc\", accuracy(y_cls, y>0, \"binary\"), on_epoch=True, on_step=False)\n", + " self.log(f\"{stage}/loss_pred\", float(pred_loss), on_epoch=True, on_step=False, prog_bar=True)\n", + " self.log(f\"{stage}/loss_rec\", float(rec_loss), on_epoch=True, on_step=False, prog_bar=True)\n", + " self.log(f\"{stage}/l1_loss\", l1_loss, on_epoch=True, on_step=False)\n", + " self.log(f\"{stage}/l2_loss\", l2_loss, on_epoch=True, on_step=False)\n", + " self.log(f\"{stage}/n\", float(len(y)), on_epoch=True, on_step=False, reduce_fx=torch.sum)\n", + " if self._ae_mode==0:\n", + " return rec_loss\n", + " elif self._ae_mode==1:\n", + " return pred_loss\n", + " elif self._ae_mode==2:\n", + " return pred_loss * 50000 + rec_loss\n", + "\n" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -1462,21 +1447,24 @@ "execution_count": null, "metadata": {}, "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [], "source": [ - "VAE_EPOCH_MULT = 1\n" + "\n" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, + "outputs": [], + "source": [ + "VAE_EPOCH_MULT = 1\n", + "l1_coeff=1.e-1\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -1490,15 +1478,15 @@ { "data": { "text/plain": [ - "{'pred': tensor(0.3960),\n", - " 'l1_loss': tensor(10.8780),\n", - " 'l2_loss': tensor(4693.0845),\n", - " 'loss': tensor(4693.1167),\n", - " 'latent': tensor(0.3399),\n", - " 'h_rec': tensor(0.3566)}" + "{'pred': tensor(0.4251),\n", + " 'l1_loss': tensor(145.0110),\n", + " 'l2_loss': tensor(4666.4360),\n", + " 'loss': tensor(4680.9370),\n", + " 'latent': tensor(0.4476),\n", + " 'h_rec': tensor(0.3790)}" ] }, - "execution_count": 27, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" } @@ -1510,14 +1498,12 @@ "x, x1, y = next(iter(dl_train))\n", "print(x.shape, 'x')\n", "if x.ndim==3: x = x.unsqueeze(-1)\n", - "\n", "c_in = x.shape[1:-1]\n", "net = PLAE(c_in=c_in, total_steps=max_epochs*len(dl_train)*VAE_EPOCH_MULT, lr=lr, \n", " weight_decay=wd, \n", - " depth=7,\n", - " hs=128,\n", - " n_latent=32,\n", - " l1_coeff=3e-3 # neel uses 3e-4 ! https://github.dev/neelnanda-io/1L-Sparse-Autoencoder/blob/bcae01328a2f41d24bd4a9160828f2fc22737f75/utils.py#L106, but them they sum l1 where mean l2\n", + " hs=64,\n", + " n_latent=12,\n", + " l1_coeff=l1_coeff, # neel uses 3e-4 ! https://github.dev/neelnanda-io/1L-Sparse-Autoencoder/blob/bcae01328a2f41d24bd4a9160828f2fc22737f75/utils.py#L106, but them they sum l1 where mean l2\n", " # x_feats=x_feats\n", " )\n", "print(c_in)\n", @@ -1535,60 +1521,47 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 29, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "========================================================================================================================\n", - "Layer (type:depth-idx) Output Shape Param #\n", - "========================================================================================================================\n", - "PLAE [64, 4096, 27] --\n", - "├─AutoEncoder: 1-1 [64] --\n", - "│ └─Sequential: 2-1 [64, 32, 27] --\n", - "│ │ └─BatchNorm1d: 3-1 [64, 4096, 27] --\n", - "│ │ └─InceptionBlock: 3-2 [64, 512, 27] 1,298,816\n", - "│ │ └─InceptionBlock: 3-3 [64, 512, 27] 381,312\n", - "│ │ └─InceptionBlock: 3-4 [64, 512, 27] 381,312\n", - "│ │ └─InceptionBlock: 3-5 [64, 512, 27] 381,312\n", - "│ │ └─InceptionBlock: 3-6 [64, 512, 27] 381,312\n", - "│ │ └─InceptionBlock: 3-7 [64, 512, 27] 381,312\n", - "│ │ └─InceptionBlock: 3-8 [64, 512, 27] 381,312\n", - "│ │ └─Conv1d: 3-9 [64, 32, 27] 16,416\n", - "│ └─Sequential: 2-2 [64, 4096, 27] --\n", - "│ │ └─InceptionBlock: 3-10 [64, 512, 27] 258,885\n", - "│ │ └─InceptionBlock: 3-11 [64, 512, 27] 382,725\n", - "│ │ └─InceptionBlock: 3-12 [64, 512, 27] 382,725\n", - "│ │ └─InceptionBlock: 3-13 [64, 512, 27] 382,725\n", - "│ │ └─InceptionBlock: 3-14 [64, 512, 27] 382,725\n", - "│ │ └─InceptionBlock: 3-15 [64, 512, 27] 382,725\n", - "│ │ └─InceptionBlock: 3-16 [64, 512, 27] 382,725\n", - "│ │ └─ParametrizedConv1d: 3-17 [64, 4096, 27] 2,101,760\n", - "├─Sequential: 1-2 [64, 1] --\n", - "│ └─LinBnDrop: 2-3 [64, 864] --\n", - "│ │ └─Linear: 3-18 [64, 864] 747,360\n", - "│ │ └─ReLU: 3-19 [64, 864] --\n", - "│ │ └─BatchNorm1d: 3-20 [64, 864] 1,728\n", - "│ └─LinBnDrop: 2-4 [64, 864] --\n", - "│ │ └─Linear: 3-21 [64, 864] 747,360\n", - "│ │ └─ReLU: 3-22 [64, 864] --\n", - "│ │ └─BatchNorm1d: 3-23 [64, 864] 1,728\n", - "│ └─Linear: 2-5 [64, 1] 865\n", - "========================================================================================================================\n", - "Total params: 9,759,140\n", - "Trainable params: 9,759,140\n", + "=============================================================================================================================\n", + "Layer (type:depth-idx) Output Shape Param #\n", + "=============================================================================================================================\n", + "PLAE [64, 4096, 27] --\n", + "├─AutoEncoder: 1-1 [64] --\n", + "│ └─Encoder: 2-1 [64, 12, 27] --\n", + "│ │ └─Sequential: 3-1 [64, 256, 27] 896,020\n", + "│ │ └─Sequential: 3-2 [64, 324] 2,345,760\n", + "│ └─Decoder: 2-2 [64, 4096, 27] --\n", + "│ │ └─Sequential: 3-3 [64, 432] 141,912\n", + "│ │ └─Sequential: 3-4 [64, 4096, 27] 277,609\n", + "├─Sequential: 1-2 [64, 1] --\n", + "│ └─LinBnDrop: 2-3 [64, 81] --\n", + "│ │ └─Linear: 3-5 [64, 81] 26,325\n", + "│ │ └─ReLU: 3-6 [64, 81] --\n", + "│ │ └─BatchNorm1d: 3-7 [64, 81] 162\n", + "│ └─LinBnDrop: 2-4 [64, 27] --\n", + "│ │ └─Linear: 3-8 [64, 27] 2,214\n", + "│ │ └─ReLU: 3-9 [64, 27] --\n", + "│ │ └─BatchNorm1d: 3-10 [64, 27] 54\n", + "│ └─Linear: 2-5 [64, 1] 28\n", + "=============================================================================================================================\n", + "Total params: 3,690,084\n", + "Trainable params: 3,690,084\n", "Non-trainable params: 0\n", - "Total mult-adds (G): 6.30\n", - "========================================================================================================================\n", + "Total mult-adds (M): 161.91\n", + "=============================================================================================================================\n", "Input size (MB): 28.31\n", - "Forward/backward pass size (MB): 287.10\n", - "Params size (MB): 20.47\n", - "Estimated Total Size (MB): 335.88\n", - "========================================================================================================================" + "Forward/backward pass size (MB): 93.45\n", + "Params size (MB): 10.12\n", + "Estimated Total Size (MB): 131.88\n", + "=============================================================================================================================" ] }, - "execution_count": 28, + "execution_count": 29, "metadata": {}, "output_type": "execute_result" } @@ -1612,9 +1585,488 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 30, "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "requires_grad: True, AutoEncoder(\n", + " (enc): Encoder(\n", + " (conv): Sequential(\n", + " (0): BatchNorm1d(4096, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (1): InceptionBlock(\n", + " (bottleneck): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 4097, 64, kernel_size=(1,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (convs): ModuleList(\n", + " (0): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 65, 64, kernel_size=(7,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (1): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 65, 64, kernel_size=(5,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (2): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 65, 64, kernel_size=(3,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (mp_conv): Sequential(\n", + " (0): MaxPool1d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n", + " (1): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 4097, 64, kernel_size=(1,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (bn): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv_dropout): Dropout(p=0, inplace=False)\n", + " (act): ReLU()\n", + " )\n", + " (2): InceptionBlock(\n", + " (bottleneck): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 257, 64, kernel_size=(1,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (convs): ModuleList(\n", + " (0): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 65, 64, kernel_size=(7,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (1): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 65, 64, kernel_size=(5,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (2): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 65, 64, kernel_size=(3,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (mp_conv): Sequential(\n", + " (0): MaxPool1d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n", + " (1): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 257, 64, kernel_size=(1,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (bn): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv_dropout): Dropout(p=0, inplace=False)\n", + " (act): ReLU()\n", + " )\n", + " (3): InceptionBlock(\n", + " (bottleneck): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 257, 64, kernel_size=(1,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (convs): ModuleList(\n", + " (0): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 65, 64, kernel_size=(7,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (1): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 65, 64, kernel_size=(5,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (2): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 65, 64, kernel_size=(3,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (mp_conv): Sequential(\n", + " (0): MaxPool1d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n", + " (1): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 257, 64, kernel_size=(1,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (bn): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv_dropout): Dropout(p=0, inplace=False)\n", + " (act): ReLU()\n", + " )\n", + " (4): InceptionBlock(\n", + " (bottleneck): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 257, 64, kernel_size=(1,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (convs): ModuleList(\n", + " (0): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 65, 64, kernel_size=(7,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (1): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 65, 64, kernel_size=(5,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (2): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 65, 64, kernel_size=(3,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (mp_conv): Sequential(\n", + " (0): MaxPool1d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n", + " (1): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 257, 64, kernel_size=(1,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (bn): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv_dropout): Dropout(p=0, inplace=False)\n", + " (act): ReLU()\n", + " )\n", + " )\n", + " (fc): Sequential(\n", + " (0): LinBnDrop(\n", + " (lin): Linear(in_features=6912, out_features=324, bias=True)\n", + " (bn): BatchNorm1d(324, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act): ReLU()\n", + " )\n", + " (1): Linear(in_features=324, out_features=324, bias=True)\n", + " )\n", + " )\n", + " (dec): Decoder(\n", + " (fc): Sequential(\n", + " (0): BatchNorm1d(324, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (1): LinBnDrop(\n", + " (lin): Linear(in_features=324, out_features=432, bias=True)\n", + " (bn): BatchNorm1d(432, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act): ReLU()\n", + " )\n", + " (2): ReLU()\n", + " )\n", + " (conv): Sequential(\n", + " (0): InceptionBlock(\n", + " (convs): ModuleList(\n", + " (0): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 17, 16, kernel_size=(7,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (1): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 17, 16, kernel_size=(5,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (2): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 17, 16, kernel_size=(3,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (mp_conv): Sequential(\n", + " (0): MaxPool1d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n", + " (1): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 17, 16, kernel_size=(1,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (bn): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv_dropout): Dropout(p=0, inplace=False)\n", + " (act): ReLU()\n", + " )\n", + " (1): InceptionBlock(\n", + " (bottleneck): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 65, 16, kernel_size=(1,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (convs): ModuleList(\n", + " (0): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 17, 16, kernel_size=(7,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (1): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 17, 16, kernel_size=(5,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (2): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 17, 16, kernel_size=(3,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (mp_conv): Sequential(\n", + " (0): MaxPool1d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n", + " (1): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 65, 16, kernel_size=(1,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (bn): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv_dropout): Dropout(p=0, inplace=False)\n", + " (act): ReLU()\n", + " )\n", + " (2): ParametrizedConv1d(\n", + " 64, 4096, kernel_size=(1,), stride=(1,)\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " )\n", + " )\n", + ")\n" + ] + }, { "name": "stderr", "output_type": "stream", @@ -1629,71 +2081,42 @@ "\n", " | Name | Type | Params\n", "-------------------------------------\n", - "0 | ae | AutoEncoder | 8.3 M \n", - "1 | head | Sequential | 1.5 M \n", + "0 | ae | AutoEncoder | 3.7 M \n", + "1 | head | Sequential | 28.8 K\n", "-------------------------------------\n", - "9.8 M Trainable params\n", + "3.7 M Trainable params\n", "0 Non-trainable params\n", - "9.8 M Total params\n", - "39.037 Total estimated model params size (MB)\n" + "3.7 M Total params\n", + "14.760 Total estimated model params size (MB)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Sanity Checking DataLoader 0: 100%|██████████| 2/2 [00:02<00:00, 0.69it/s]" + "Epoch 49: 100%|██████████| 38/38 [00:04<00:00, 7.75it/s, v_num=122, val/loss_pred=0.393, val/loss_rec=7.11e+3, train/loss_pred=0.520, train/loss_rec=758.0] " ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/media/wassname/SGIronWolf/projects5/elk/discovering_latent_knowledge/.venv/lib/python3.10/site-packages/lightning/pytorch/trainer/connectors/logger_connector/result.py:211: You called `self.log('val/n', ...)` in your `validation_step` but the value needs to be floating point. Converting it to torch.float32.\n" + "`Trainer.fit` stopped: `max_epochs=50` reached.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch 0: 0%| | 0/38 [00:00" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1737,13 +2140,13 @@ ], "source": [ "df_hist = read_metrics_csv(trainer1.logger.experiment.metrics_file_path).ffill().bfill()\n", - "for key in ['l1', 'l2', 'loss_rec']:\n", - " df_hist[[c for c in df_hist.columns if key in c]].clip(0, 1e6).plot()\n" + "for key in ['loss_rec']:\n", + " df_hist[[c for c in df_hist.columns if key in c]].plot(logy=True)\n" ] }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 32, "metadata": {}, "outputs": [ { @@ -1752,13 +2155,13 @@ "" ] }, - "execution_count": 31, + "execution_count": 32, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1768,13 +2171,73 @@ } ], "source": [ - "df_hist[[c for c in df_hist.columns if key in c]].plot(logy=True)\n" + "a = df_hist[[c for c in df_hist.columns if 'train/l2' in c]]\n", + "a = (a / l1_coeff ).rename(columns=lambda x: f'{x} * {1/l1_coeff}')\n", + "b = df_hist[[c for c in df_hist.columns if 'train/l1' in c]]\n", + "pd.concat([a, b], axis=1).plot(\n", + " logy=True\n", + " )\n" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.1" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "l1_coeff\n" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "a = df_hist[[c for c in df_hist.columns if 'val/l2' in c]]\n", + "a = (a / l1_coeff ).rename(columns=lambda x: f'{x} * {1/l1_coeff}')\n", + "b = df_hist[[c for c in df_hist.columns if 'val/l1' in c]]\n", + "pd.concat([a, b], axis=1).plot(\n", + " # logy=True\n", + " )\n" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -1786,15 +2249,15 @@ { "data": { "text/plain": [ - "{'pred': tensor(0.4050),\n", - " 'l1_loss': tensor(20.0563),\n", - " 'l2_loss': tensor(109.0741),\n", - " 'loss': tensor(109.1343),\n", - " 'latent': tensor(0.6268),\n", - " 'h_rec': tensor(0.1520)}" + "{'pred': tensor(0.3610),\n", + " 'l1_loss': tensor(46.2532),\n", + " 'l2_loss': tensor(499.3340),\n", + " 'loss': tensor(503.9594),\n", + " 'latent': tensor(0.1428),\n", + " 'h_rec': tensor(0.1245)}" ] }, - "execution_count": 33, + "execution_count": 35, "metadata": {}, "output_type": "execute_result" } @@ -1811,7 +2274,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 36, "metadata": {}, "outputs": [ { @@ -1820,7 +2283,7 @@ "torch.Size([64, 27, 4096, 1])" ] }, - "execution_count": 34, + "execution_count": 36, "metadata": {}, "output_type": "execute_result" } @@ -1832,14 +2295,14 @@ }, { "cell_type": "code", - "execution_count": 56, + "execution_count": 37, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -1847,17 +2310,7 @@ }, { "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1868,11 +2321,14 @@ ], "source": [ "from matplotlib import cm\n", - "latent = y['latent']#.reshape(64, 24, 12) # [Batch, Latent, Layer]\n", - "vmax=6\n", + "latent = y['latent'].cpu()#.reshape(64, 24, 12) # [Batch, Latent, Layer]\n", + "vmax=latent.abs().max()\n", "for i in range(4):\n", " plt.subplot(2, 2, i+1)\n", - " plt.imshow(latent[i], cmap=cm.coolwarm, interpolation='none', aspect='auto', vmin=-vmax, vmax=vmax)\n", + " vmax = latent[i].abs().max()\n", + " plt.imshow(latent[i], cmap=cm.coolwarm, interpolation='none', aspect='auto'\n", + " , vmin=-vmax, vmax=vmax\n", + " )\n", " plt.xlabel('layer')\n", " plt.ylabel('neuron')\n", " if i<2:\n", @@ -1882,35 +2338,37 @@ " plt.ylabel('')\n", " plt.yticks([])\n", " plt.grid(False)\n", + " plt.colorbar()\n", "# plt.colorbar()\n", "plt.subplots_adjust(wspace=0.05, hspace=0.05)\n", "plt.show()\n", "\n", "\n", - "plt.imshow(latent[1], cmap=cm.coolwarm, interpolation='none', aspect='auto', vmin=-vmax, vmax=vmax)\n", - "plt.xlabel('layer')\n", - "plt.ylabel('neuron')\n", - "plt.colorbar()\n", + "# plt.imshow(latent[1], cmap=cm.coolwarm, interpolation='none', aspect='auto', vmin=-vmax, vmax=vmax)\n", + "# plt.xlabel('layer')\n", + "# plt.ylabel('neuron')\n", + "# plt.colorbar()\n", "plt.show()\n", "\n", "latentf = rearrange(latent, 'b n l -> (b n) l').flatten()\n", - "plt.hist(latentf, bins=55)\n", + "vmax=(latentf.abs().mean() + 5* latentf.abs().std()).item()\n", + "plt.hist(latentf, bins=55, range=[-vmax, vmax], histtype='step')\n", "plt.title('latents by layer')\n", "plt.show()\n" ] }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 38, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "tensor(4.1168)" + "tensor(8.9606)" ] }, - "execution_count": 36, + "execution_count": 38, "metadata": {}, "output_type": "execute_result" } @@ -1931,7 +2389,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 39, "metadata": {}, "outputs": [ { @@ -1948,43 +2406,515 @@ "\n", " | Name | Type | Params\n", "-------------------------------------\n", - "0 | ae | AutoEncoder | 8.3 M \n", - "1 | head | Sequential | 1.5 M \n", + "0 | ae | AutoEncoder | 3.7 M \n", + "1 | head | Sequential | 28.8 K\n", "-------------------------------------\n", - "1.5 M Trainable params\n", - "8.3 M Non-trainable params\n", - "9.8 M Total params\n", - "39.037 Total estimated model params size (MB)\n" + "28.8 K Trainable params\n", + "3.7 M Non-trainable params\n", + "3.7 M Total params\n", + "14.760 Total estimated model params size (MB)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch 199: 100%|██████████| 38/38 [00:03<00:00, 10.24it/s, v_num=99, val/loss_pred=0.0731, val/loss_rec=2.24e+3, train/loss_pred=0.0839, train/loss_rec=193.0]" + "requires_grad: False, AutoEncoder(\n", + " (enc): Encoder(\n", + " (conv): Sequential(\n", + " (0): BatchNorm1d(4096, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (1): InceptionBlock(\n", + " (bottleneck): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 4097, 64, kernel_size=(1,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (convs): ModuleList(\n", + " (0): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 65, 64, kernel_size=(7,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (1): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 65, 64, kernel_size=(5,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (2): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 65, 64, kernel_size=(3,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (mp_conv): Sequential(\n", + " (0): MaxPool1d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n", + " (1): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 4097, 64, kernel_size=(1,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (bn): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv_dropout): Dropout(p=0, inplace=False)\n", + " (act): ReLU()\n", + " )\n", + " (2): InceptionBlock(\n", + " (bottleneck): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 257, 64, kernel_size=(1,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (convs): ModuleList(\n", + " (0): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 65, 64, kernel_size=(7,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (1): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 65, 64, kernel_size=(5,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (2): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 65, 64, kernel_size=(3,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (mp_conv): Sequential(\n", + " (0): MaxPool1d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n", + " (1): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 257, 64, kernel_size=(1,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (bn): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv_dropout): Dropout(p=0, inplace=False)\n", + " (act): ReLU()\n", + " )\n", + " (3): InceptionBlock(\n", + " (bottleneck): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 257, 64, kernel_size=(1,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (convs): ModuleList(\n", + " (0): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 65, 64, kernel_size=(7,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (1): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 65, 64, kernel_size=(5,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (2): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 65, 64, kernel_size=(3,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (mp_conv): Sequential(\n", + " (0): MaxPool1d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n", + " (1): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 257, 64, kernel_size=(1,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (bn): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv_dropout): Dropout(p=0, inplace=False)\n", + " (act): ReLU()\n", + " )\n", + " (4): InceptionBlock(\n", + " (bottleneck): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 257, 64, kernel_size=(1,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (convs): ModuleList(\n", + " (0): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 65, 64, kernel_size=(7,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (1): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 65, 64, kernel_size=(5,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (2): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 65, 64, kernel_size=(3,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (mp_conv): Sequential(\n", + " (0): MaxPool1d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n", + " (1): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 257, 64, kernel_size=(1,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (bn): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv_dropout): Dropout(p=0, inplace=False)\n", + " (act): ReLU()\n", + " )\n", + " )\n", + " (fc): Sequential(\n", + " (0): LinBnDrop(\n", + " (lin): Linear(in_features=6912, out_features=324, bias=True)\n", + " (bn): BatchNorm1d(324, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act): ReLU()\n", + " )\n", + " (1): Linear(in_features=324, out_features=324, bias=True)\n", + " )\n", + " )\n", + " (dec): Decoder(\n", + " (fc): Sequential(\n", + " (0): BatchNorm1d(324, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (1): LinBnDrop(\n", + " (lin): Linear(in_features=324, out_features=432, bias=True)\n", + " (bn): BatchNorm1d(432, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act): ReLU()\n", + " )\n", + " (2): ReLU()\n", + " )\n", + " (conv): Sequential(\n", + " (0): InceptionBlock(\n", + " (convs): ModuleList(\n", + " (0): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 17, 16, kernel_size=(7,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (1): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 17, 16, kernel_size=(5,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (2): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 17, 16, kernel_size=(3,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (mp_conv): Sequential(\n", + " (0): MaxPool1d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n", + " (1): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 17, 16, kernel_size=(1,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (bn): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv_dropout): Dropout(p=0, inplace=False)\n", + " (act): ReLU()\n", + " )\n", + " (1): InceptionBlock(\n", + " (bottleneck): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 65, 16, kernel_size=(1,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (convs): ModuleList(\n", + " (0): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 17, 16, kernel_size=(7,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (1): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 17, 16, kernel_size=(5,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (2): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 17, 16, kernel_size=(3,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (mp_conv): Sequential(\n", + " (0): MaxPool1d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n", + " (1): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 65, 16, kernel_size=(1,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (bn): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv_dropout): Dropout(p=0, inplace=False)\n", + " (act): ReLU()\n", + " )\n", + " (2): ParametrizedConv1d(\n", + " 64, 4096, kernel_size=(1,), stride=(1,)\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " )\n", + " )\n", + ")\n", + "Epoch 49: 100%|██████████| 38/38 [00:02<00:00, 17.00it/s, v_num=123, val/loss_pred=0.943, val/loss_rec=7.25e+3, train/loss_pred=0.104, train/loss_rec=755.0]" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "`Trainer.fit` stopped: `max_epochs=200` reached.\n" + "`Trainer.fit` stopped: `max_epochs=50` reached.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch 199: 100%|██████████| 38/38 [00:03<00:00, 9.89it/s, v_num=99, val/loss_pred=0.0731, val/loss_rec=2.24e+3, train/loss_pred=0.0839, train/loss_rec=193.0]\n" + "Epoch 49: 100%|██████████| 38/38 [00:02<00:00, 16.76it/s, v_num=123, val/loss_pred=0.943, val/loss_rec=7.25e+3, train/loss_pred=0.104, train/loss_rec=755.0]\n" ] } ], "source": [ - "net.ae_mode(False)\n", + "net.ae_mode(1)\n", "trainer2 = pl.Trainer(precision=\"16-mixed\",\n", " gradient_clip_val=20,\n", " max_epochs=max_epochs, log_every_n_steps=3, \n", - " \n", " # enable_progress_bar=False, enable_model_summary=False\n", " )\n", "trainer2.fit(model=net, train_dataloaders=dl_train, val_dataloaders=dl_val)\n" @@ -1992,7 +2922,7 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 40, "metadata": {}, "outputs": [ { @@ -2006,63 +2936,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Testing DataLoader 0: 8%|▊ | 3/38 [00:00<00:01, 17.89it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/media/wassname/SGIronWolf/projects5/elk/discovering_latent_knowledge/.venv/lib/python3.10/site-packages/lightning/pytorch/trainer/connectors/logger_connector/result.py:211: You called `self.log('test/n', ...)` in your `test_step.0` but the value needs to be floating point. Converting it to torch.float32.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Testing DataLoader 1: 21%|██ | 4/19 [00:00<00:00, 19.21it/s] " - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/media/wassname/SGIronWolf/projects5/elk/discovering_latent_knowledge/.venv/lib/python3.10/site-packages/lightning/pytorch/trainer/connectors/logger_connector/result.py:211: You called `self.log('test/n', ...)` in your `test_step.1` but the value needs to be floating point. Converting it to torch.float32.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Testing DataLoader 2: 21%|██ | 4/19 [00:00<00:00, 21.18it/s] " - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/media/wassname/SGIronWolf/projects5/elk/discovering_latent_knowledge/.venv/lib/python3.10/site-packages/lightning/pytorch/trainer/connectors/logger_connector/result.py:211: You called `self.log('test/n', ...)` in your `test_step.2` but the value needs to be floating point. Converting it to torch.float32.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Testing DataLoader 3: 22%|██▏ | 4/18 [00:00<00:00, 21.17it/s] " - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/media/wassname/SGIronWolf/projects5/elk/discovering_latent_knowledge/.venv/lib/python3.10/site-packages/lightning/pytorch/trainer/connectors/logger_connector/result.py:211: You called `self.log('test/n', ...)` in your `test_step.3` but the value needs to be floating point. Converting it to torch.float32.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Testing DataLoader 3: 100%|██████████| 18/18 [00:01<00:00, 10.80it/s]\n" + "Testing DataLoader 3: 100%|██████████| 18/18 [00:00<00:00, 23.26it/s]\n" ] }, { @@ -2071,11 +2945,11 @@ "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
        "┃        Test metric        ┃       DataLoader 0        ┃       DataLoader 1        ┃       DataLoader 2        ┃\n",
        "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
-       "│         test/acc          │    0.5563439130783081     │    0.6093488931655884     │    0.5993322134017944     │\n",
-       "│       test/l1_loss        │    21.259716033935547     │    20.227296829223633     │    19.770179748535156     │\n",
-       "│       test/l2_loss        │    1053.3695068359375     │     2235.240478515625     │     2699.593994140625     │\n",
-       "│      test/loss_pred       │    0.13514529168605804    │    0.07309918850660324    │    0.2141098976135254     │\n",
-       "│       test/loss_rec       │    1053.4332275390625     │     2235.301025390625     │     2699.653564453125     │\n",
+       "│         test/acc          │    0.1719532608985901     │    0.6460767984390259     │    0.37896493077278137    │\n",
+       "│       test/l1_loss        │    107.15355682373047     │     96.78995513916016     │     97.97341918945312     │\n",
+       "│       test/l2_loss        │      6058.6162109375      │      7239.423828125       │      7134.775390625       │\n",
+       "│      test/loss_pred       │    1.8178952932357788     │    0.9434764385223389     │     1.302729845046997     │\n",
+       "│       test/loss_rec       │       6069.33203125       │      7249.103515625       │     7144.57275390625      │\n",
        "│          test/n           │          2396.0           │          1198.0           │          1198.0           │\n",
        "└───────────────────────────┴───────────────────────────┴───────────────────────────┴───────────────────────────┘\n",
        "
\n" @@ -2084,11 +2958,11 @@ "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", "┃\u001b[1m \u001b[0m\u001b[1m Test metric \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m DataLoader 0 \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m DataLoader 1 \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m DataLoader 2 \u001b[0m\u001b[1m \u001b[0m┃\n", "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", - "│\u001b[36m \u001b[0m\u001b[36m test/acc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.5563439130783081 \u001b[0m\u001b[35m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.6093488931655884 \u001b[0m\u001b[35m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.5993322134017944 \u001b[0m\u001b[35m \u001b[0m│\n", - "│\u001b[36m \u001b[0m\u001b[36m test/l1_loss \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 21.259716033935547 \u001b[0m\u001b[35m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 20.227296829223633 \u001b[0m\u001b[35m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 19.770179748535156 \u001b[0m\u001b[35m \u001b[0m│\n", - "│\u001b[36m \u001b[0m\u001b[36m test/l2_loss \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 1053.3695068359375 \u001b[0m\u001b[35m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 2235.240478515625 \u001b[0m\u001b[35m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 2699.593994140625 \u001b[0m\u001b[35m \u001b[0m│\n", - "│\u001b[36m \u001b[0m\u001b[36m test/loss_pred \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.13514529168605804 \u001b[0m\u001b[35m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.07309918850660324 \u001b[0m\u001b[35m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.2141098976135254 \u001b[0m\u001b[35m \u001b[0m│\n", - "│\u001b[36m \u001b[0m\u001b[36m test/loss_rec \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 1053.4332275390625 \u001b[0m\u001b[35m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 2235.301025390625 \u001b[0m\u001b[35m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 2699.653564453125 \u001b[0m\u001b[35m \u001b[0m│\n", + "│\u001b[36m \u001b[0m\u001b[36m test/acc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.1719532608985901 \u001b[0m\u001b[35m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.6460767984390259 \u001b[0m\u001b[35m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.37896493077278137 \u001b[0m\u001b[35m \u001b[0m│\n", + "│\u001b[36m \u001b[0m\u001b[36m test/l1_loss \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 107.15355682373047 \u001b[0m\u001b[35m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 96.78995513916016 \u001b[0m\u001b[35m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 97.97341918945312 \u001b[0m\u001b[35m \u001b[0m│\n", + "│\u001b[36m \u001b[0m\u001b[36m test/l2_loss \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 6058.6162109375 \u001b[0m\u001b[35m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 7239.423828125 \u001b[0m\u001b[35m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 7134.775390625 \u001b[0m\u001b[35m \u001b[0m│\n", + "│\u001b[36m \u001b[0m\u001b[36m test/loss_pred \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 1.8178952932357788 \u001b[0m\u001b[35m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.9434764385223389 \u001b[0m\u001b[35m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 1.302729845046997 \u001b[0m\u001b[35m \u001b[0m│\n", + "│\u001b[36m \u001b[0m\u001b[36m test/loss_rec \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 6069.33203125 \u001b[0m\u001b[35m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 7249.103515625 \u001b[0m\u001b[35m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 7144.57275390625 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m test/n \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 2396.0 \u001b[0m\u001b[35m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 1198.0 \u001b[0m\u001b[35m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 1198.0 \u001b[0m\u001b[35m \u001b[0m│\n", "└───────────────────────────┴───────────────────────────┴───────────────────────────┴───────────────────────────┘\n" ] @@ -2102,11 +2976,11 @@ "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
        "┃        Test metric        ┃       DataLoader 3        ┃\n",
        "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
-       "│         test/acc          │    0.4210045635700226     │\n",
-       "│       test/l1_loss        │     16.12659454345703     │\n",
-       "│       test/l2_loss        │     2273.49072265625      │\n",
-       "│      test/loss_pred       │    0.1512577384710312     │\n",
-       "│       test/loss_rec       │     2273.538818359375     │\n",
+       "│         test/acc          │    0.2511415481567383     │\n",
+       "│       test/l1_loss        │     94.82392883300781     │\n",
+       "│       test/l2_loss        │     6796.65478515625      │\n",
+       "│      test/loss_pred       │    1.0872248411178589     │\n",
+       "│       test/loss_rec       │     6806.13720703125      │\n",
        "│          test/n           │          1095.0           │\n",
        "└───────────────────────────┴───────────────────────────┘\n",
        "
\n" @@ -2115,11 +2989,11 @@ "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", "┃\u001b[1m \u001b[0m\u001b[1m Test metric \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m DataLoader 3 \u001b[0m\u001b[1m \u001b[0m┃\n", "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", - "│\u001b[36m \u001b[0m\u001b[36m test/acc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.4210045635700226 \u001b[0m\u001b[35m \u001b[0m│\n", - "│\u001b[36m \u001b[0m\u001b[36m test/l1_loss \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 16.12659454345703 \u001b[0m\u001b[35m \u001b[0m│\n", - "│\u001b[36m \u001b[0m\u001b[36m test/l2_loss \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 2273.49072265625 \u001b[0m\u001b[35m \u001b[0m│\n", - "│\u001b[36m \u001b[0m\u001b[36m test/loss_pred \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.1512577384710312 \u001b[0m\u001b[35m \u001b[0m│\n", - "│\u001b[36m \u001b[0m\u001b[36m test/loss_rec \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 2273.538818359375 \u001b[0m\u001b[35m \u001b[0m│\n", + "│\u001b[36m \u001b[0m\u001b[36m test/acc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.2511415481567383 \u001b[0m\u001b[35m \u001b[0m│\n", + "│\u001b[36m \u001b[0m\u001b[36m test/l1_loss \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 94.82392883300781 \u001b[0m\u001b[35m \u001b[0m│\n", + "│\u001b[36m \u001b[0m\u001b[36m test/l2_loss \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 6796.65478515625 \u001b[0m\u001b[35m \u001b[0m│\n", + "│\u001b[36m \u001b[0m\u001b[36m test/loss_pred \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 1.0872248411178589 \u001b[0m\u001b[35m \u001b[0m│\n", + "│\u001b[36m \u001b[0m\u001b[36m test/loss_rec \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 6806.13720703125 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m test/n \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 1095.0 \u001b[0m\u001b[35m \u001b[0m│\n", "└───────────────────────────┴───────────────────────────┘\n" ] @@ -2138,7 +3012,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Predicting DataLoader 0: 100%|██████████| 19/19 [00:01<00:00, 14.98it/s]" + "Predicting DataLoader 0: 100%|██████████| 19/19 [00:00<00:00, 30.96it/s]\n" ] }, { @@ -2152,16 +3026,15 @@ "name": "stdout", "output_type": "stream", "text": [ - "\n", - "Predicting DataLoader 0: 100%|██████████| 19/19 [00:01<00:00, 18.45it/s]\n", + "Predicting DataLoader 0: 100%|██████████| 19/19 [00:00<00:00, 31.89it/s]\n", "probe results on subsets of the data\n", - "acc=60.43%,\tn=2396,\t[] \n", - "acc=56.50%,\tn=1016,\t[instructed_to_lie==True] \n", - "acc=63.33%,\tn=1380,\t[instructed_to_lie==False] \n", - "acc=62.21%,\tn=2265,\t[llm_ans==label_true] \n", - "acc=60.42%,\tn=1511,\t[llm_ans==label_instructed] \n", - "acc=29.77%,\tn=131,\t[instructed_to_lie==True & llm_ans==label_instructed] \n", - "acc=60.45%,\tn=885,\t[instructed_to_lie==True & llm_ans!=label_instructed] \n", + "acc=51.25%,\tn=2396,\t[] \n", + "acc=60.93%,\tn=1016,\t[instructed_to_lie==True] \n", + "acc=44.13%,\tn=1380,\t[instructed_to_lie==False] \n", + "acc=53.86%,\tn=2265,\t[llm_ans==label_true] \n", + "acc=40.83%,\tn=1511,\t[llm_ans==label_instructed] \n", + "acc=6.11%,\tn=131,\t[instructed_to_lie==True & llm_ans==label_instructed] \n", + "acc=69.04%,\tn=885,\t[instructed_to_lie==True & llm_ans!=label_instructed] \n", "probe accuracy for quadrants\n" ] }, @@ -2198,13 +3071,13 @@ " \n", " \n", " tell a truth\n", - " 0.63\n", + " 0.44\n", " NaN\n", " \n", " \n", " tell a lie\n", - " 0.30\n", - " 0.6\n", + " 0.06\n", + " 0.69\n", " \n", " \n", "\n", @@ -2213,8 +3086,8 @@ "text/plain": [ "llm gave did didn't\n", "instructed to \n", - "tell a truth 0.63 NaN\n", - "tell a lie 0.30 0.6" + "tell a truth 0.44 NaN\n", + "tell a lie 0.06 0.69" ] }, "metadata": {}, @@ -2224,13 +3097,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "⭐PRIMARY METRIC⭐ acc=60.43% from probe\n", - "⭐SECONDARY METRIC⭐ acc_lie_lie=29.77% from probe\n" + "⭐PRIMARY METRIC⭐ acc=51.25% from probe\n", + "⭐SECONDARY METRIC⭐ acc_lie_lie=6.11% from probe\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2240,7 +3113,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAG0CAYAAADgoSfXAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOx9d5glVZn+Wzd1zmG6JzB5YIAhKSBBJKgMLiqIigFXwEXXjK4YUVBBF3d1DbjqKmZBEX+oBAnOgAOSGdLMAJOY2DnnG6rO74+qU3Xq1Kl47+17u+e8zzPPdN++lavO+er93u/9FEIIgYSEhISEhIREiRAr9Q5ISEhISEhIHNqQwYiEhISEhIRESSGDEQkJCQkJCYmSQgYjEhISEhISEiWFDEYkJCQkJCQkSgoZjEhISEhISEiUFDIYkZCQkJCQkCgpZDAiISEhISEhUVLIYERCQkJCQkKipEiUegfCYHh4GLlcrqDrbGtrQ39/f0HXWW6Qxzj3Md+PD5DHOB8w348PmP/HWOjjSyQSaGpq8v9ewbY4C8jlcshmswVbn6Io5nrnqyu+PMa5j/l+fIA8xvmA+X58wPw/xlIen0zTSEhISEhISJQUMhiRkJCQkJCQKClkMCIhISEhISFRUshgREJCQkJCQqKkiCRgveeee3DHHXdgZGQES5cuxeWXX45Vq1YJv3vttddi27Ztjs+PP/54fOELX4iyeQkJCQmJeYpcLoepqalS74YrpqenkclkSr0bRUOU46uurkYikV89TOilH3nkEfz617/GFVdcgdWrV+Ouu+7C9ddfj+9+97toaGhwfP8zn/mMrRx3fHwcV111FU455ZS8dlxCQkJCYn4hl8thcnISdXV1iMXKk7hPJpMFreosN4Q9Pk3TMD4+jpqamrwCktBX+84778Q555yDs846C4sXL8YVV1yBVCqFBx54QPj92tpaNDY2mv+ef/55VFRU4DWveU3knZaQkJCQmH+Ympoq60BEwolYLIa6urq82axQYUwul8Pu3btxwQUX2HZk3bp12L59e6B1bNy4EaeeeioqKytdv5PNZm2RmaIoqKqqMn8uFOi6CrnOcoM8xrmP+X58gDzG+YBCHZ8MROYe6DXL59qHCkbGxsagaRoaGxttnzc2NqKrq8t3+Z07d2L//v348Ic/7Pm922+/Hbfddpv5+/Lly3HDDTegra0tzO4GRkdHR1HWW06Qxzj3Md+PD5DHOB+Qz/FNT08jmUwWcG+Kg7mwj/kgyvGlUil0dnZG3uasOrBu3LgRhx12mKvYleLCCy/E+eefb/5Oo63+/v6C2sErioKOjg709PTMSzc9QB7jfMB8Pz5AHuN8QCGOL5PJlL0eQ2pGxMhkMuju7nZ8nkgkAhEJoYKR+vp6xGIxjIyM2D4fGRlxsCU8ZmZm8M9//hMXX3yx73aSyaRrZFaMh5gQMi8HBxbyGOc+5vvxAfIY5wPm+/FJuCOf6x4qOZdIJLBixQps2bLF/EzTNGzZsgVr1qzxXPaxxx5DLpfDa1/72mh7KiEhISEhMQ9x8skn46c//Wmpd6OkCK0UOv/887FhwwY8+OCDOHDgAH72s58hnU7jzDPPBADceOONuPnmmx3Lbdy4ESeeeCLq6ury3mkJCQmJ+QiSTpd6FyTKCK95zWuwadOmUu/GrCC0ZuTUU0/F2NgYbr31VoyMjGDZsmX44he/aKZpBgYGHIrarq4uvPTSS7j66qsLstMSEhIS8w3khaeh3fh1KO/+EGJnnlfq3ZEoMbZt24bR0dFDxpMrkoB1/fr1WL9+vfBv1157reOzhQsX4tZbb42yKQkJCYlDAmTvDkDTgD07AJQuGCEH9kC75SeIvfW9UNYcXbr9IATIlIgpSlUELlP97W9/i+985zt46qmnbGXJl112GZqamvCJT3wCX/3qV7F582ZMTU1h9erV+PznP48zzjjDc7333nsvzjzzTCSTSQwNDeHqq6/G448/bpIAH//4x202G5qm4cc//jF+97vfoaurC62trbjkkkvwyU9+EoBOClx33XX4xz/+gXQ6jdWrV+P666/HCSecEP78FAGzWk0jISEhIeECVdP/19SS7gZ59jFg+1aQxzeVNBhBJg3tY+8syaZjN94KVLh7YbE4//zz8eUvfxn//Oc/TU3k8PAwHnzwQfz617/G5OQkzj77bHzuc59DKpXCbbfdhssuuwybNm3CokWLXNd7//3344Mf/CAAIJ1O45hjjsFHPvIR1NXVYcOGDfjEJz6BpUuX4vjjjwcAfPOb38TNN9+Ma665BieddBL6+vqwc+dOAMDk5CTe/va3o6OjA7/4xS/Q1taGF154AZqm5XOaCgoZjEhISEiUA2gQopY2GDG3X+KgaK6gsbERZ511Fv785z+bwchdd92F5uZmnHbaaYjFYjjqqKPM73/2s5/FPffcg/vuuw+XXXaZcJ3d3d148cUXcdZZZwEAOjs78e///u/m3y+//HI8+OCDuOOOO3D88cdjYmICN910E6677jq88516ALds2TKcdNJJAHTvrsHBQdx1111oamoCoPt3lRNkMCIhISFRDqBvqaUORuh+lPqtOVWhMxQl2nYYXHjhhfjsZz+Lb3zjG6ioqMDtt9+Ot7zlLYjFYpicnMS3v/1tbNiwAX19fcjlcpiZmcHBgwdd13fffffhxBNPNPu9qaqK73//+7jzzjvR09ODTCaDTCZjOpPv2LED6XQap59+unB9W7duxdFHH20GIuUIGYxISEhIlAMMJoKUmpEok2BEUZTAqZJS4w1veAMIIdiwYQOOPfZYPP7446Z+8mtf+xoeeughfPnLX8ayZctQWVmJD37wg56dce+//3688Y1vNH//0Y9+hJtuuglf/epXccQRR6C6uhrXXHONaU7m1V4lyN/LAbIJgISEhEQ5wEyPlJiRKJNgZC6hsrIS5513Hm6//Xb85S9/wcqVK7Fu3ToAwFNPPYV3vOMdOO+887B27Vq0t7fjwIEDruuanJzEI488gnPPPdf87Mknn8S5556Liy66CEcddRSWLl2K3bt3m39fvnw5Kisr8fDDDwvXuXbtWmzduhXDw8MFOuLCQwYjEhISEuUAUzNSuJYX0fbDCEKIDEbC4MILL8SGDRvw+9//HhdeeKH5+fLly/G3v/0NW7ZswdatW/HRj37UUzj6wAMPYMWKFViyZIltHZs2bcKTTz6JHTt24HOf+xwGBgbMv1dWVuKjH/0orr/+evzxj3/Enj178PTTT+OWW24BAFxwwQVoa2vDBz7wATz55JPYu3cv7rrrLjz11FNFOBPRINM0EhISEuUAtUw0I0YQUvJ00RzD6aefjsbGRuzatcsWjFxzzTX49Kc/jbe+9a1obm7GRz/6UUxMTLiu595778Ub3vAG22ef/OQnsW/fPrz3ve9FVVUV3vve9+Lcc8/F+Pi4+Z0rr7wS8Xgc//3f/43e3l60t7fjfe97HwC9id0tt9yCr371q3jf+96HXC6HNWvW4Prrry/wWYgOGYxISEhIlAO04qdpyEAvyAN3QTnnzVCaXZqXzcJ+zEfEYjFs3rzZ8fmSJUvwxz/+0fbZpZdeavv98ccfBwDkcjls3LgRv/3tb21/b2pqws9//nPf7X/yk580fUV4LF68uKwt52WaRkJCQqIcoBa/tJdsugfkvj+DPHS/x35IzUipMDIygiuuuALHHXdcqXdl1iGZEQkJCYlyANVoFFMzMjOt/5/1cDYlMhgpFVpbW3HllVeWejdKAsmMSEhISJQDZqOahm7Dq9U7TdNIAavELEIGIxISEpFBhgZASi24nCcgs+HAmjNYF80rGJHMiMTsQwYjEhISkUAO7IH2uctBfvX9Uu/K/MBs9KYxU0AyGJEoL8hgREJCIhr6ugAApK+7xDsyTzAbzEigNI0MRiRmHzIYkZCQiAY6oclJqzDQit+gjphpGo9rJoMRiRJABiMSEhKRQDQZjBQUs1Daa6ZpPJgRQqQDq8TsQwYjEhIS0SCrLgoLbRY1I17XTDIjEiWADEYkJCSiwUzTeOgPJIJDakYkAJx88sll7ZRaLMhgREJCIhrohCaZkcKATv5FLe3VW84HC0ZkyXZQvP3tb8dXvvKVgqzr7rvvxiWXXBJ6uQMHDmDlypWYnJwsyH7MNqQDq4SERDRIp87CQi2+gDWQsZpkRgoOQghUVUUi4T/ltrS0RNrGvffei1NPPRU1NTWRli81JDMiISERDZIZKSxmoZomiIC1XIJMQghmclpJ/hGv88PhyiuvxKOPPoqbbroJixYtwqJFi/CHP/wBixYtwsaNG7F+/XosX74cTzzxBPbs2YPLLrsMxx57LFavXo03velN2LRpk219fJpm0aJFuPnmm/GBD3wAK1euxGmnnYb77rvPsR9st99nn30W73rXu3D00UfjiCOOwEUXXYQXXnjB9v3R0VF89rOfxbHHHosVK1bg7LPPxv33Wz2LnnzySbz97W/HypUrceSRR+I973kPRkZGAp+XsJDMiISERDSYb9BSM1IQzEY1TS6EgLXEQWZaJbj4D9tLsu0/XLwGlQkl0He/9rWvYffu3TjiiCPwmc98BgDw8ssvAwC+8Y1v4Ctf+QoOO+wwNDQ0oKurC2effTY+97nPIZVK4bbbbsNll12GTZs2YdGiRa7b+M53voOrr74aV199NX7xi1/gYx/7GB5//HE0NTUB0AOLJ598Et//vm5AODExgXe84x247rrrQAjBT37yE7zvfe/Dww8/jNraWmiahksuuQSTk5P4wQ9+gKVLl2L79u2Ix+MAgC1btuDiiy/GxRdfjK9+9atIJBJ45JFHoBUxQJXBiISERDTIEtDCgtGMEEKgKMEmw1AIImCdjR458wj19fVIpVKorKxEe3s7AGDnzp0AgKuuugpnnHGG+d2mpiYcddRR5u+f/exncc899+C+++7DZZdd5rqNd77znbjgggsAAJ///Odx00034dlnn8VZZ50FANi4cSPWrl2Ljo4OAMDpp59uW/5b3/oW1q5di0cffRRveMMb8NBDD+HZZ5/Fgw8+iJUrVwIAli5dan7/Rz/6EY455hh885vfND87/PDDQ5+bMJDBiISERDRIn5HCgj2PRAOUeOG3oQboTVMmaZqKuII/XLymZNsuBI455hjb75OTk/j2t7+NDRs2oK+vD7lcDjMzMzh48KDnetauXWv+XF1djbq6OgwMDJifsSkaAOjv78e3vvUtPPLIIxgcHISqqpienja3s3XrVnR2dpqBCI+tW7fi/PPPD328+UAGIxISEtEgNSOFBasVUTUgVsRgZA74jCiKEjhVUq6orq62/f61r30NDz30EL785S9j2bJlqKysxAc/+EFkMhnP9SSTSdvviqKYKZNMJoMHH3wQH//4x82/X3nllRgeHsbXvvY1LF68GKlUCm95y1uQzerVVJWVlZ7b8/t7MSAFrBISEtFApGakoGC1ImZDuyJuww1lEozMJSSTyUB6iqeeegrveMc7cN5552Ht2rVob2/HgQMH8tr2o48+ioaGBlv658knn8Tll1+Oc845B4cffjhSqRSGhobMv69duxbd3d3YtWuXcJ1r167Fww8/nNd+hYUMRiQkJKJBMiOFBcuMFKuiJlBvGumsGxZLlizBM888g/3792NoaMg1MFm+fDn+9re/YcuWLdi6dSs++tGP5i0Kve+++/DGN77RsZ0//elP2LFjBzZv3oyPf/zjNrbjlFNOwcknn4wPfvCD2LRpE/bt24eNGzfigQceAAB87GMfw3PPPYcvfOEL2LZtG3bu3Ilf/epXtoCm0JDBiISERDTIN+jCQuXSNEXZhh6MeJauyusaGh/60IcQi8Vw5plnYt26da4akGuuuQYNDQ1461vfiksvvdT8fj647777bHoRAPj2t7+N0dFRrF+/Hp/4xCdw+eWXo7W11fadn/70pzj22GPxkY98BGeddRauv/56qMY9uHLlStx8883Ytm0bzj//fLzlLW/BfffdZ1bbFANSMyIhIRENspqmsGAn/2IxI2E0I/K6BsbKlStxxx132D67+OKLHd9bsmQJ/vjHP9o+u/TSS22/P/7447bfRYHNiy++CAB44YUXMDExgVNOOcX296OPPhp333237TNekNrU1ITvfOc7gqPRccopp+Avf/mL698LDcmMSEhIRIPsTVNYaMXVjBBCgpX2lkk1jYQ/crkcvv71rzsErnMRkhmRkJCIBk1qRgoKW5qmCMwIu06ZppkXOP7443H88ceXejcKAsmMSEhIRIOspiksbGmaIgQCLNsie9NIlBlkMCIhIRENUltQWBS7moYNRiQzIlFmkMGIhIRENBDpwFooEELs57EYPiM5NhgpXwFrMfufSBQHhbhmMhiRkJCIBrOaRqZp8gY/mBejtDeoZqSEAtbq6mqMj4+XVUBCNBVkfBSkmA0M5zA0TcP4+LjDbTYspIBVQkIiGiQzUjjwaZlySNMQUryGfS5IJBKoqanBxMTErG3TD2SwD+jtAloXQGnvRCqV8rVvn8uIcnw1NTVIJPILJ2QwIiEhEQ2ymqZw4N+6i/EWngsoYGW3rWlAEY2uREgkEqivr5/VbXpB+/vtIH/7E5TXrUf8fR9FZ2cnuru7vY3j5igURSnZ8ck0jYSERDQwQQiR7Eh+4JkQn2CE5HJQ//Oz0H77v8G3ETZNA0jWC7DOQa5I/YIkAMhgREJCIipsLe/n31virIKf9P3SNP09wK6XQJ7YFHwbatb6OYiAVbRf8wgkaCqM6nekZqSokMGIhIRENLAByDyetGYFIZkR8/thPF5szIjXutkgc35OwNpv/hfaZy4FGR/1/zIN3IrVSVkCgAxG5gzIs49DvfE6kPGxUu+KhIQO9u1a6kbyA1894/fWrkborKuGLO3lf55HIC89B4yPAgf3+n/ZuBYkl/X5okQ+kMHIHIH2wN3Ac0+APPNIqXdFQkKHZEYKh8jMSIjzngtZTRN2/XMJ9PwGSb3INM2sQAYjcwU5o9RqoK+0+yEhQcFOaFIzkh/4iS4wMxI1TSNejhByaAhYKUsURJRKpIB1NiCDkbkCOpAM9pd2PyQkKDSuBFQiOrjgw9dgK4pLapDSXn598/W6msxIgAAjzHclIkMGI3MFxkBCBntLvCMSEgZszMg8nbRmC2E1I1HSNEFMzxxVPfP0utLxNEiAoUkB62xABiNzBfRBGJRpGokygSY1IwUDX7Xix4wwfw9qTmVjW9yCR/46ztcgk46nYYIRmaYpKmQwMldAH4TRYZCsVHVLlAFs1TRSM5IXeGYkqIAVCB4w2HxGDnFmhJ7fIAGGFuK7EpEhg5G5AhrBEwIMS92IRBlAVtMUDmF706gRRKZBHFgPgWCEEMIwI/4VMkSmaWYFMhiZK2AfBFlRI1EOkD4jhYOjN43P+dQCBBY8pIBVB3uupWakbCCDkbkCZiAhc1A3Qrr2gQwPlno3JAqJQ8GPYrbg8BnxmfhslUwBgxEpYNXBBiNh0jTSZ6SokMHIXAH7IMyxYIRMjkP7+pXQvvPlUu+KRCEhfUYKh5A+I3YxatAeKwHYFH4/5qMdPBuUBQkwpIB1ViCDkbkC9kGYY8EIxkb1/ZfMyPyCrKYpHPjzF0bAGpQZsTmwBqymmY/X1ZamCVAMYKZpZOFAMSGDkbkCdQ6naUyDpnn4lnUoQ2pGCoewwQirKQnKSgVJ0xwSmhEmqAjEjMyvNA0ZGdT7nG19ptS7YkOi1DsgERDqHGZGonQYlSh/yDRN4RC2miaK+63UjOgIrRmZX2ka8vxTwHNPQFMUxI86vtS7Y0IyI3MARFPtg8fwEMhcejDowCknrHkFIgWshUPU3jRACJ8RGYwA4DQjh14wAtp9OJMu7X5wkMHIXAD7ECiKPvgMD5Ruf8IiSrtzifJHAdI0Qd1D5z0c1TRFKO2N4sA6L4ORiNU0RNNfDOc66DFkMqXdDw4yGJkLYB+e5jb9/7mUqpHMyPxEnqZnZNdL0P7jX6E99kABd2puwtEYL1Rpb8Bzb/MZCciMzMcXiFzEapqg3y930GPIymBEIizYh6e9E8AcE7GaAlYi34TnE/LUjJAdW4HxUWDL5gLu1ByFg5EII2AtYJqGF5nPS2aEDUZCVNMA8yNVI4MRicigD48Sg9LWof88l4KRKPltifJHvpoRusx8nPDCYjbSNLK0V4ettDdENQ0wP1xYZTAiERn0AUgkgKZW/eehOaQZsU1akhmZN8i3Nw1dfj5OeGERmhmJUk0je9MAsAcUYappgn6/3EGPv8warsrS3rkAevPE40AqZf9sLiDKW5xE+UOLkCoQLE8kWyboTRNCMxIpTXMIMyNsa40w1TTA3Bp33aA5mRHt9t8AUxOIveECoLOzJLslmZG5gBzDjMSMSzaXBglZAjo/QfJkvOjy80EUmC/CpmnU8OfeNvEGFrDOw2uTT5pmXjAjzmCEPLEJ5MG/ARNjJdopGYzMDdCbJ54AlLj+81ya1KVmZH7CJmCVmpG8kI/pWWBmRKZpAOSXppkPzIgZjGStggLqOZKqKM0+QQYjcwP0gYlbzAiZpUEindPyr4CRaZr5iXw1I2aV1Tyc8MKCY0J8/Swi9aZhNAJu5/yQsIMPKUjVQjIp5Q7W98nUjxgsiQxGJDzBakZmMU3TN5HF+27bge892p3XeohkRuYn8jU9o8HMfBjg84UjTVMMB9bwXXtn66VnNkHYoCysZiRXXqLPSGCPOcu5sZYwGIkkYL3nnntwxx13YGRkBEuXLsXll1+OVatWuX5/cnISt9xyC5544glMTEygra0N73//+3HCCSdE3vFDCmY1TdIKRmZhUt/aN4W0SvBs92R+K7IJHSUzMm+Qb5WUTNNYoEFAIqEzoaG69kYwPTuk0zRhNSPzrJqGvXeyGZBkyjoPyVRp9gkRgpFHHnkEv/71r3HFFVdg9erVuOuuu3D99dfju9/9LhoaGhzfz+VyuO6661BfX49Pf/rTaG5uxsDAAKqrqwtyAIcEcqVhRrrGdepueEZFOqehIhGRSJMC1vmJfDUjRKZpTNDnIpHUn/dQpmeya28o2DQjQUzPrGvhcMotEMjWZ6Dd9kvE3v8xKMtWF2UbJlR7MGLzG6mYQ2maO++8E+eccw7OOussLF68GFdccQVSqRQeeEBs6bxx40ZMTEzgqquuwhFHHIH29nYceeSRWLZsWb77fuhAZTQjCg1Gik9t02AEAHon8qAno4jtJMofkhkpHDTuzTQMMxIpTROwtHc+Pq/5MCNBHFsjgDx8P3DgFZDnnizK+m1wBCNGikZR9GC4RAjFjORyOezevRsXXHCB+VksFsO6deuwfft24TJPP/00Vq9ejZtuuglPPfUU6uvrcdppp+GCCy5ALCaOhbLZLLKMIYuiKKiqqjJ/LhTougq5zmLAjMYTSSjxOAgARdMC7Xc+x9g1xgQjk1ksbaoMvQ5A31c6VSmk8Od7rlzHqCjb4+OYkdD7x5iele0xFhCex0gnPBqMaKr3uWCCEYWQYOeNY0ZEy/CeL0HHGaCM71MOipozxyOoOf/9ZYIRxRiLC32MpOeAsS2f614IsPdOLmc1zEumzDm5FNcwVDAyNjYGTdPQ2Nho+7yxsRFdXV3CZXp7e9Hf34/TTz8dX/jCF9DT04Of/exnUFUV73jHO4TL3H777bjtttvM35cvX44bbrgBbW1tYXY3MDo6Ooqy3kJhqr4OgwAqqqtQ29yMQQCpRALtIcxpwh4jIQQ9E1aAORWrQmdEM5zx2hqMGD+3t7Uh0doeaT1+KPfrmC/K7fh6EgnQV4amxkZUh7w/hquqMAEgGY+bx1Zux1gMiI5xpKoK4wASVVXIAUjF41jgcT4HUxWYMn5uaW5GRYBz360AZjhCiPB5ntrdgEHm94b6OtSGvK7lfg3HamowavwcB3zHtQPEeplqrKsDUNhjJJqGg33dIABqKyrQWGTTsf5EAjPGzy31dYhV16AHQKyysqTPYdEdWAkhqK+vx4c+9CHEYjGsWLECQ0ND+Otf/+oajFx44YU4//zzzd9plNbf349cAQVEiqKgo6MDPT09Zd3ATevvBwBkVA3DY7opTXpmBt3d/lUuQY4xndMjf1YTMjSVxVTWiqB3HBxA98Jot4s2MmL+3NfTDSVb2BTTXLmOUVGux5ejCnwAw4ODGA1wP7JQJ8YBANn0DHp6esryGAsJr+uojunTY85Iw2Zmpj2fb3Vywvx5sL8fSqP/uc/NzFi/aJpw/drgoO330eFhjAe8ruV6n/LQhofMn9W0/zjK6kRGBvpRDRT0GMlAL4jxLE2MjWI65HMUFurUlPnzQHc3lEqd8dbiyaI8h4lEIhCREGp2qa+vRywWwwgzuQDAyMiIgy2haGxsRCKRsKVkFi1ahJGREeRyOSQSzl1IJpNIJsW5q2Lc5KTMu8lS50QST0BhNCNh9tntGDOqho/f+QoSMQXf/5fliMf0wI9N0QBAz0Qm8jlinR9v3z2F7VsP4FOndiIVL2xleblfx3xRdsfH0NdEi+BHQ5dXrXu57I6xCBAeI1/NoHo/3+wESTQ1mIiV00doghQML9AkavjrWu7X0OZE63OeAdjvc+NluJDHSLr3W7/ksq7rJYToDVJb2vNKo9iOP5sGoetKVZT0OQw1GyQSCaxYsQJbtmwxP9M0DVu2bMGaNWuEyxx++OHo6emBxlzQ7u5uNDU1CQMRCQEEpmeFEv3tHkqjZyKLA2MZvDJsvelS8Woqrt+oPfkIWA3lfzqWxO92TOORfePY3OVeLnzHS0P40t/3YSwt/SfKGjbTswjXSgpYLeQlYI1QTQOIxan8Z/PRDj4X3IGVEFJ0B1ZTLwJ4Xnfy8P3QvnAFyIN357dBdhuZjOUxUsKyXiBCNc3555+PDRs24MEHH8SBAwfws5/9DOl0GmeeeSYA4MYbb8TNN99sfv+Nb3wjJiYm8Mtf/hJdXV3YvHkzbr/9dpx77rkFO4h5D+MBUIpQ2rtjcNr8eVu/Rd/RYGTdAr0Eu3fCPWL3gv4w6zf/toblyBq7/WL/tOv3/7h1EFt6p/DQntL1SZAIgHz9Y+gy87FiIyxMAavBCBejay8/8YoqoA45nxGf4IK/N4vhM9J9MNj6e43vsUxKFLCsGlvaW8KyXiCCZuTUU0/F2NgYbr31VoyMjGDZsmX44he/aKZpBgYGbBRSa2srvvSlL+FXv/oVrrrqKjQ3N+O8886zVeQcqrh92yDiMQVvOaLZ+4uiRnkFGsC3D1p55K19U+a+0GDk2I4aPNM9iYxKMDyjornKumVyGsG9O0bw/7YN4si2anz6tE4oioLtA9O45fkBHBzPYHg6h/ckWvAWAM82W+yZWzAyMJXD6Iz+sDzdNYF/ObypIMcpUQTYqmnyKO2dJQdWoqlQYvFZ2VZoaFbFHIDil/YC4mt2SAQj9jSNJ/jjLzoz4rF+6i2Tb0DE+ayYd0GJmZFIeZL169dj/fr1wr9de+21js/WrFmD66+/Psqm5hyyKkEi5l8aNZZW8ctndGHqmcsbUF/hMUiyjfKKyIy82DcNYpT8Uc3IkoYUWquT6JvMonc8YwYjW3uncOPjPWbQsmnvGE5eUotjO2pw/T8OYGTGeshvUxfg3FjSFozsGppBRtUcupGdTHD0Qu8U0jkNKiG46ek+nNBZg9OW1hfkuCUKgHx705DZS9OQ0WFo134MykmvQ+zdHyz69kLDmGiUZEqfHPzOSRSPF94jQxTEHBLBiJ0ZoWOe+LuzwIwwwQjxDEaMv+VrSc9e00zG+r2EVvCA7E1TULzYP4V33bodt7ww4Pvd/knrhto7MuPxTViDSII1Pct/kBhPq+ge19ediCkYTas4OJaBRoj5+cK6FDpq9be1nokssqqGX27uw5f+vg9d4xk0VMRx4qIaAMDPn+7Dj57owciMisX1KXzjDYdhQW0SE0jgz0teh/01HYgBqE3FkNOILfCg2DlkfZZRCbb2TeGvLw7j77tG8aMnepBVZ09U9fddI/j2w11mtZEEh3zN7EI2yiMzUyDZiAPxwT3AxDjIS89HW77YcGhGfCa9IH1mvJZxW+5QCEb4gMKLHeE1MwVmRsjkBDA2Emxf6D1SSGYkmzF9RpS5phmRcMedLw8jpxE8sm/c97sDtmAk7fFNMMxIHDBo5gxR8M1NB3DL8/3m1/omsvjzi4PIGNF8TiP4r4cO4jsbdwj1HpQV6axL4ohWvbxrW/80BiZzyGo6w9NWk8QCIxjpncjiu4924/YXh0AAvH5lA370lhW46vRFWFCbxOB0Dv/cNw4FwCdO6cRR7dU4b3UjAOCPy84BAKyqU0wdyjZBqobuU3VSvzUf3juOO17WS/HGMxo2d084likGJtIqfvJkLzbtHcOj+/2vZ7FACMEtz/fj4398FhOZMhMTFqprL//2KdpUJg3tCx+E9q3Ph98Ou61ynVwF1TSeCNmbRlhxE0TAWq7nKx/wAYVXgFHsNA2bogG8WQ/jniD5MiNuDqySGZkfmMqqeOKAPlEeHMtgxudtemDKuqn5YGTX0Aw+c88e3LbFqPk3q2msRnnPVi3BY/sn8PsXBvF8zySyqoavPrAfv9jcjz9v0yfvZ7om8dDeMdzy9H48+IpTDLrDYCbWtFThyHY9QNjaO2WmXjpqU4jHFHTU6gPkQ3vH8PDeccQU4PNnLMLHX9OJmlQcFYkY/u1VlpHZm49owuGtumPu61c2IgUVmqIHUcc3xbC2Td/WS4xgFtAnXsqMnG9oRTbsHsVExjqX/xAchxd6JzL41TN9uPLuV/DIvuDLbtg9iozBwmzrE+tbAGD7wDRufWHAwdikcxq+888ufGXDPgxNRx/Abts6iFueH8Bje4awYddI5PUUBXlqRswAOUglzugwMDEGHNwbejvGxoxtlefkSkxmhApYffYzbNde0du0KL3jYE/K83zlBf4Yg+g0DJACp2lIz0H7B15BqFooZoQLRsyOvZIZmRd4bP+EOXlpBNgz7M12DEyxzIjl6fHIvjF8/r692DE4g7+8NKQP2GZvGqua5oWaxeYy//dUL25+fgAHDJ3HA6+MgRCCh/dak+/PnurFCDcpUhZidUsljqLBSN8UnuvRy24X1us3J2VG6PrfsLIRpyyps63rpMV1uGBtM16zpBbvPdYyuKmriOMMxWJvjmsE1rbpgcpL/dPQmEmsZyKLyYyGhCHqZfvyvWlNIwDgiQMTmAzAEKgawc+f7sWH/rIb/2/bEF4ZTuMvLw47vpdVNWzpnbLth0YI7t5ufXcbFzRRHBhL45qN+/G75wdw707r+9NZDV978AD+sWcMz/VM4Uv378PgVPi3mQ27RvDb56yU3993jZaFf0NO09NnGjtR5cOMBJnwQqZ0Cr58sSGwgw/0fSCSx4ixoPd6Rb+XGSYzKn6xuQ/7R33YZRZ88OE1ufNpmkJrRigzUt+o/+8ZGNFgJF9mhE3TZC07eMmMzA88+Mqo7ffdw946EFYzsm8kDUIIHt8/jhse6jKDmrG0qr9VC6pptlQvMZffP5rB/zPYkJiiV8Js65/GYwZT01qTwnhGxU+e6jWXIYSYlTRrWqtweGsVYgrQP5Uz13VYg35zdtRZBnSVCQXvPqZVeEyXndCOL5yxGJVcd983kQNQiIaGzDjW1BKsaK5EKq5gPKNh5+CM6fRKmZrlTRWoq4ibDEprdQKXn7AAi+tTyGoEj+4fR9dYBk8emIAqeLubzKi47sED+MtLwyCAydLsGpqxMRiqRvD1Bw/gS3/fh79tHzE/39w1iZ6JLKqM49g/msHYjH2QmMqq+OY/DmLKqFW+b4ceKGRUDV97YD+29E6hKhFDS3UCXeMZfPH+fXh8/7hjfwkhwmPoncjgf5/o0c/fmiak4jHsHUljt0+QOxv47bP9+OL9+/Dn1pOsD/Pp2stMeF3jGbw8IGCi8k2zzHLlTmjwpb1hNCNBzoloEhUFMdx1zKni+7Nc8JeXhvDnF4fwg8eCu5Y6RKKebERx0zRmJc3iZfrvuRye7Z7EQc50EgCmNeDp5iOQyeYZILL3C8uMJOdYaa+EE4NTWTzfo789n7GsHpv2jGHXkHcwwqZppnMa+iaz+NuOEQDAWcvrsWNwxjQiazIb5enByGiyBnurdPbhX49rw6+f1ZmHUw+rQ0JRsGnvGG58rAczOQ1tNQn8z0XH4l9/8yQe2TeOXUMzWNlcif5JvYQ2ruiTfyoew5Ht1djSO4X6ijjesLIBFx2ll/kuqLXouwuPbEFTVbjbZrk2iq8/92PU5KYRP/MqKDEFa1oqsaVvGlfdq9PuZyytR12FPvmvatb1K+etbsSL/dN4//HtSMYVnLm8Hr99bgA3Pd1nBgFHtlXhytMWgnZzUDWCazbux47BGaTiCj51aidOWVKHS27bgYmMhj0jM1jdogcnv3m2H88Z123j7lGzjJiyIm9c1YCnuyZxYEwP7l5jsEGEEHzv0W4cGNOriyYyKvaOpvHywAye7Z7Etv5p1CRjuObsJWiqTODqDfvQM5HFNzYdRFt1AqctrcexHdXYPZzGvTuGMTSt4sj2Kpy4qBbrVzciFY/hT1uHkNOAYzqq8aETFyAbS+L+l/qwYdcIVjYH6xsxk9OgwG7zny+yqoa/G+miv7WegLfuuAdxohVEMzIwkcZVf9uD8YyK619/GI42tEW274ZkhtI5DY/uH8eiKQXLoCBWrm/6xjM+nahEBQDFT0cTVjxMJ1FFYVJW3szIKzWduCZ9Amb+8DLaa1I4qr0Kl53QjpqUd3n0yEwOz3ZN4MTFtahOxjGd1XDz8/1oqEjgoqOaC9qE7RnDPPHlgRnsGJw2n21P8MGHC9OwY3AafT3TOAkKYpRF4oKRTXvG8OTBCbz3mFZ01EVIc/TqPd2UhYeBbHsWf69ejR9t1H1EjuuoxjkrG3F8Zw0OjmXwP1WvQ88xtTh+ej++rBHTLdsPqkaQ04g1DvACVooSp2lkMFIA/OOVMRDo6YdTltRi054x7PYLRgxmJKboY8KL/dN4oVd/sN5+dAtufWEQB8Yy2D00gxNoNU1cr6bZ2rgCALCssQIXHtmMF/un0TWewYdevQA7h2awae+Yqfs4fWk9Dl9QhxM6a/BU1yS29U1hZXOl+fa5rKnSLK/9zGkLsWckjaPaq2wlt3WpGE5cVIORGRUXrPXxRBFBVXHk6B79Z2OwO2dlI14amAaV1mxiUkqrW/Rg5LSl9Tj1sDpz8DpjmR6MTGX1STYZV7CtfxqfvPMVfPOttVhRpWs9dgzOoCYVw9fPOQwrjcBmTUsVNndPYvuAHow8vHcMt7+oM0AK9Cqe7vEMchrB012TUACct6YJMzmiByN9U2Yw8sArY3hs/wQSMQWfP2MR7tkxgo27R3HL8/2mKPfDJ3WYjMy3zl2Kv7w4hPt3jaJ/Koc/v6i/zbF4vmcKz/dM4eWBaVx+Qjs27NaZtneta4WiKHjz0Z24/6U+bNozhstOaEfSx0r/wGga/3HPXszkNDRXJbC2rQofeFU7WqqTIET3jGmqjJvnNp3TkNUIan0mmicOTmDc0PAMpurxTPPhePXgixFNz2iAoU8O3/r7dowbKbj/e7IX33nTMhwYTeOXz/RjaTyNcyubsGBm2LsUk8Mftwzij1sHATSg/tQv4/3dD+D1gu8NTmXRWJkIPMBHRVbV0DORQXNlAsk4sy1NxT8WHI/vD6/Fe5ecibcd+If1J0Lwt+0jePzAONavNlKkTDBCNA0gBBt2j+LRfeN433FtWMZ12NZyOUzGK1GjqNbka5z/F/umkNUIjumoMZ/P8UQVvnX0v2ICCUDTGauu8QxeGpjG1a9bbJt4KbNZk0rgpd5xfOruVzA4lUNHbRLvP74Nf3hhEHsMXVxjVRyvX9kY6FwRQjA0nUNzVUJ4vcfTqq367u7tw/jkKVXIqgRpVXO/lwXMiEYI7t85ipGZHDSijwGUqX3TqjfjAzv/CsX4LqBP8L96ps98jrf2TuG61x+GhfUpjEznUJWMBXoJ2JpoQ9+CNryutgGTiWr8pvlk82/P9kzh2Z4p0FtSi9cCAJ6pWoKbnx/A+47z7/eiEYIv3r8P2wensbqlEq9eWIs3IQ4zZMtmrGe3xGkaGYzkiZ7xDG41hKZnr2gwJ799o2lkVWIfcAyoGsGgod84sq0KW/qm8ecX9TfhxfUpLK6vwIrmCvxjD3RaPpdDVoljBFVYEIvhhcZVAHR31Jii4OozLf3IcZ01qK+Im1bqrzV8Oda0VuGpLn0yBvQyZMDSbwBAU1VCyHooioKrz1zi+DwwBNbVZ69owOuW6fv2fO8UvvGPA2Z6ahXzdsMOQgtqU/jkKZ3om8jirBX6st99pBvb+qfxpTu24Ovn6A8poE/i9FoAeqpmc/ckXh6YxhtXNeL/ntRTVm87shm7hmbwXM8U/rl3HPvH9EHzpMW16KxL4cj2Kty7c8QMMoanc7jpaX3Zd69rxeGtVSBEZ1aeNViWYxZU4/SllqamsTKB9x/fjneta8WTByewuWsSL/ROoakqjnNXNWJVSxU2d03gN8/24+G943hlOI2cRnBkW5Wp5TlpaTNaqhMYnMrhjpeHceFa7zfM3z0/YIqoh4wqp+d6JnH+4U148uAEdg2lce6qRnzk5A7M5DR89t696J/M4n/OW+b5hrdhlx4k1SRjmMxquK/zZD0YCck4pHMank90YOfS12PxzAAyu0bwwI5+xBWgMhnD3tE0fvZULx7eN47xtIpnAPzl5M9hfdej+KCmQokHG7oeP6BXQiVAMJaqxU8Xn4tTsyqqk9ZEdf/OEdz4eA+qkzEc01GNM5c14DVLal3P78hMDqm4Yq6jdyKDpw5O4vUrG8wJ6NH94xicyuK4jhok4wru2TGCR/aNo2/yRWgEOKK1Cte9fokZVI6TBG5a9WYQKLht2Tk4p+dJNGkaBmdUfO/RbpN5fa5nCmvbqvDBRCOWQhc/jmSBH206aArou8Yz+M55y1FlVKRlVA3XPD6Knadejc9t/z2O79umByKEYM/wDL74933QCPD+49pwgaZBVWL4nyPfg96qFizANL70L0eiZzyDHz/Zi/2jGXzm3r24cG0zTllSh7/tGMbd24ehEX2MeWU4jbTByPVMZHHDQ/qbfzKmIKsR/PSpXhzZVm3q0dzujY27R/G37SPYO5rGmw9vwr+9eoHje8/1TEIjQE0qhsmMhof2jOOs5ZP4wWM9GJnJ4aMnd+DM5Q0Yns7hn/vGsLAuheM6a5BVCZ5sW4fJRBXO6X4SMTWHB3aPmmlRikRMQU4juHvx6WjKjOPokV14XjsMg3dswYvdI9g/qr/wNVXGMTidw+fv34u6VBwHxjJYWJfE1845DG01SeQ0gqGpHFprEogZ99S+0TR+/Uwfnlz5Lv1+mZ5A7arzMRGvxNLGCnzhjEX4+65RPHFgHPuM7bxuZg+O2Ps0fnL4Rbht6yCWNlbgDGMM3Tk4g6e7JtBclcDi+hSOaKuCoijY3DWJl4wXz5cHZvDywAwePuJSfOG5m1ClZvAPZQmGlEpgRS0w1YHzJ7Iobs9gd8hgJA/kNIJv/7ML0zkNR7ZV4ZwVDYgp1sOxfzSNFc2VjuX06FtnRY7trMGWvmmzL8zJi/Xod7nxZvPK8AygqvjR4RfhwaGVePc+FVuaVgIA1nVUO9adiCl47dI63LV9BJ11SXNCPtwIOrYbotWtRoXIke0BaM18YTNosn6mb6HHd9bgK2ctxnUPHkBdKo7FHgPV2SsabL9//fWH4Ssb9mNr3xQ+e+9e5DSCjtokzlttd25dY5Qubx+cxlNdExhN68zAJce2YePuUTzXM4V7dw6b6bN3HN0CAGYwsGtI17b85MleTGQ0rGiqwAVH6izR4a2VWNpQgb2jacQV4IoTFwgnsopEDKcvrcfpAuO2pY0VqEjE8JMne8188duParGdq/Wrm/C75/rxq2f6sX1gGu88uhUddUnbxAoAu4dm8IhRYv3NNxwGDboHzM6hGfz+Basr6707R3BMRzWe7Z40K7r+sGUAnzxlIQD9/t4+MI3ne6fQUpUw3XgB4MpTO3H9Pw5ic8sRGKhoQBvRMJVV8cvN/djWP4UzltXjjSsb0cgFt0PTOdzyfD8efGUMmcYzgUbjD4/qOf+LjmpBa3US//tEj5m2XNlciTotjWdHYvjbotNwYtckXrXEfh8QQjCWVtEzkUVrdQIt1Un0T2axbzSDmAL8dGk/rt5KcLBmATbtGcN64/4YncnhF8/0AQCmshoe2z+Bx/ZP4IjWKlz+qnaT3aJ4ZXgGn79vL+IxBf9+YgcaKuO44aGDmMxo2DuSxkdO7sDuoRn85yauSoLDSwPT+L+nevHRk/Wh/7d1x2Eiqfv1zMQr8OclZ+JNYzP4/MYuDE/rwc/pS+vx8N4xvNg/jS8sfzeunL4ZCgh+uK8FY5rO1FUnY+gaz+JnT/fi46/pBCEEP36iF9tGVCCewv+sfge+NfEDdEwOgGj6/UyzNb96th+vJA7Dyyddhd6qFlSoGXw+vhVLG4/H0sYKrGqpxDf+cRA7h2bw62f7zfSweUxGwH58Zw0+enIHfvucfp2XN+mT6w8e68ELvVO4/h8HcFR7NWIK0F6TRGddCsd2VqM6GUdW1fDlDfttuqE7Xh7GsqYKB6NC78VzVjRgW980dg7N4MsbLKv0/3mkG4/tH8cz3ZOYyekH2VGbxEzrWzFipAATmoqzc1nc+bKemj22oxodtSl01CVx9ooG/OP5ffj5jgx+t+I85kD1+yUZU/CJUzpxTEc1vrJhP/aOpE336K7xLL54/z684+gW/GnrIHomslhYl8JZK+qxrW/a3Pe4piIGDU+la4GOVwMAPnTiAnTWpfC+49rwvuPa0D+ZRUYl6PjZ74Du59DVsgx3tL4K3/5nF17qn0JNKo7btg7asm7nrGjAJ07pNJmbN6xswJrWKtz8XD/2YgE+8+orkY4nkY0ZGqXD1gATwKl5VP7lCxmM5IE/vDCA7YMzqEnG8OnTFpqT64qmSrzQO4VdQzPCYIROeC1VCazg6NSTjVQADUZ6JrLoVZN4uP04AMAtr2SB6nbEiGZOlDwuWNuCfaMZ/MuaJnNSXNNSZb6tHBzLmJPPUW3idRQUAZT/6xbU4KdvXYlYTAlFlSdiCj772kW46r596BvXj+l9x7U5GKk1BtvSPZ41S5/PWtGAeEzBa5bU4UdP9KBvUr8ux3VUm7nntpok2qoT6J/K4SN/3Y1hQ2fz8dd0ImHsp6IouODIZnzv0W5cdFSLKfwNi/NWN2Ln4Aw27B7FiqYKnLCwxvb3tx/VghiAm5/vx6P7J/Dofv1NeElDCutXN+Ks5Q2oScVN073Tl9ZhrXGP3HDuUty2ZRBPHpzAaYfVYXgmh7++NIzvPdqNjEqgQK+tePCVMVx0ZAv6p3L4zj+7bM0KKxMKNKKzaSctrsNRY3uwtX4ZfrzmbTh2qgF/u3uP2VDxd88N4A8vDODc1U1419EtyGp6quGOl4fMiaFVncThgzuwt6YTB2oWYE17LS5e1woFwH07R7BzaAZHtFbhK2ctRvXBXfj5Hx7EX5e8Dr98bhDHLarH3duH8Yctg0jnNGhED54AvYLrx29egae79PNzeGsVGmMq3tj9FH6x6s24b+eIGYz8+tl+TBrB5b+f1IHH9o/jzpeH8dLAND57716cvrQO/3pcGxbUppDOafj2P7uM/ddfROh5A/QU4cXrWnDbVj3ga65KYCytIqcRHNNRjTetacLrjlqGx17eh69t3I/7do6isTKBluoE/l5zOADgouYp/GmoGn9bdAqe/IceiCxpSOHzZyzC4voKXHJsK777SDee7wX+c92l+oY1YGlDBT59WicmMhqu/vs+/H3XKOKKgkRcwYbdo4gB6Jzqw8Hqdtxw5Pvw5eduwpYDM9jWP42KuIL1qxvxl5eGsSnXDFQBNdkpfPylW7Fs3VLz+rdUJ/GfbzwMm/aM4a7tI9g1NIOljRW47IR2LKxL4tnuKdTW1+OU9hhiCvCpUxfiXeta0VaTRCKm4MpTO/HJu17BgbGMWZlH0VadwNVnLsadLw/j5YFp1KRiePe6VozMqLht6yB+/EQvtg/MYGvfFKqSMXzpdYvNCf34zhosa6zA9x/TmY11C6qxsrkSf35xyHxGljZWYGAyq9+f8Wqk1Awy8RRuXfZ6dAznsHtYD/g+c/oimxv2WxYlMLzhXtx+2FmoyU7hWAzj1a8/AzVkBqtbKtFSrU/m17/+MNyzYxgL61JYVJ/CDQ8dRNd4Fj983GJbusYz+J1RHacAOHlJLS6585uYzAH/edJHMKzG8bqhrTiq/Qj7uanRt6Ea4+i/HtgA7bTX466Xh3EXI7w/vlMfL57rmcSG3aOor4jjhV49zXOxcR2O76zB9b99CK/U6i8cK7KDOHqmG8rwIJRjT7S1+5htyGAkIrKqhr8YUeeHT+owbxhAf5N7oXfKtaKG6kVaa5JY2mhNXE1VCVMvUV8RR2t1AgNTOdxSuRa5WALVioYpolOvyye7UZs6Urj+9tokrnv9YbbPalJxLKpP4cBYBn99STctW1iXdLy5FgMkoCdCfWW0fWmqSuBbb12Hj/xhM1a1VOK0w+oc36mt0I//4FjGpC0py1JXEcfxhqYGAN5xtL1a6Kj2ajy4ZwzDMyoqEzFcdkKbI8g8e0UDTuisQUNl9N4niqLgwyd1YG1bFY7pqHawK/GYgrcf3YITFtbgF8/04ZXhNMbTKvaPZvDTp/rw86f70F6bRPd4FjEFeBdT9ZSIKXjXMa3mZzmN4KX+abOi6m1HNmP/WAZPHJjA/zzSjT0jeqqoriKOdQuqsbVvynzro+ft3N6nsLV+GTa3rMXmaQDIoq06gfOPaMI/945j++AM7np5GBt2jSKjauab25qWSlx6QjsO/9XXoWzfCgAY/95tWLF0CYYH+kAIwTVnLcZTXZM4ZUkdqpIxEE3D2/duxMaOE7FvFPjqA/tN8TGLREzBeFrFXduHTT3BCQtrgDENZ/Y8jd+sOA+7hnRaO6tp+LuRdvrQibrG5/DWKpx/eBN+99wANu4excN7x/HY/gmcvrQOqkawfzSDpqoEzl5ej9tfHIJGgNctq0fvRBYvDUzjJ0/2mumSa89eggW1SczkNDRW6rqH1toKvGphLS45rg2/ebbfTPFCUXBG72ZccuQKbHmlDy83LEPXRA6t1Ql89ewl5qTXUp3ENWcvwf99/xbc23YCFKLhLQ2TuOS8NabO6+1HteCPWwdx784R87y8b6mC02/5P1x14pXYW9OJfzv1aiRe0PfznUe34u1Ht6CzLoVHn96O07bdh9f2PYsKLQto9vRsMh7DOSsbcfaKBkxmNFSnYmbqYf2aCnR2dqK7u9ssQe9kUn6t1Ul8/ZzD8NTBCRDorTP6JrPY2jeF/qkc/uMendlUoOvXTlhYC40Q7BtN44kDE7bj+fx9ezE4lUMyppgsy8sDM2iojOPida1IxBQsb6rAxt2jeP3KRrx2aR3Sql6xmLj9V1i342F8zGCA/ns7AaDgtUvrnW05NBXv2/03nHfwETRlxpE49kQsPul9tmME9DGEHTeuf8NSXLthP7onMrjwyGact7oJj+0fxxMHJrC0sQLrVzeioy4F9Q+9QCaDb6+awua/3I3TpvYAuMhxXwMwtS7xXAYffPUCvHphDX7wWA+yqoYPndiB1xopm98/P4BbXhgwNXGnH1Zvzk+t1Qlcv/mH+EfHq7Bsogtr2qqh5HLA3p2I/csJiNUmxdueBchgJCJeHphBWiVoqIzb9AEAsKJJDzB2DYnLMPsNz4nW6gRaqxOoTsYwldVw0qJa88EGdHZkYGoCm1L628lFTROobF+AX20dw9l9mwGcE2qfD2+twoGxDDYa4sgjXZiVgiNKu/OQOKqzHr+6aDXiintfoMNbK80UyJqWSixhGIyzVzTgqa5JQ6dhp+bfsa4FOUJwVHs1zlxe70iLUBQisEvGFbxhVaPnd1Y0V+Lr5+jB5lhaxcN7x3D39mHsH82YNv5nLm/A4np3hiYRU/Afpy3E5+/bi0UNFXj3MW04MKYP+nQSf82SWnzmtEVIxhVMZVX89cVhjMzkcOZyfdA7deAF5HI5vFK7ED3Lj8XCVctw8bpW1KTiuGBtC57rmcQvNveZKcgj26rw5iOacMoSXZTMlow2pmKoZM5rfWXCnpLTNNTmpvH2vRvwy1VvNgORd69rNb/XWBXHY/sn8O1/duGOl4aQNdb/6oW1wIiGutwUThnciofajsX3Hu0yz9XZKxpwBKOdaqlO4hOndOL8w5vwi2f68HzPlM008MpTOnFcZw3OMIKQkxbXYnPXJL724AE8bgQiJy+uNV80+FJ3ALjoyGYQQsy3+9rdW3HpzjugvPEqvOeVe3HNcR9CbVLBtUwgwl67D+69Cyd2P4P67CRWX3gBYoyg+T3HtmJJQwo7hmbQM57FssYKXFA7CJIZwxf2/QU/bX8ddtYtRo7o7R7eulZnic5b04Rzn98G0vOk7byLoCgKar36ablgRXOlI5AfT6v41kMH8Xyvfk0vOa4NJyzU09UxRcGVp3TiZ0/3IhmL4fDWSvzqmX6TgTuqvcrU6XzkZHuV2ZnLG3DmcuseqkwoeN3yBqjjO4HcDN627wH8YtVbMJzVxwthU07j+FvThnVDQI+P5qoE/udNy6ASYgaJ561pwnlruG0YJdfNNSmc3fM0UF3rvlL6UmcEJScsrMVPL1gJjdkGoKeYn+2ZNJuRvmUts02ioVLL4tyux/TfG1foXiPA3GyUJwHTGOzYjhrH5Ed1GruHZjAynXNMUgNGOqC1OglFUXD0gmo8eWDCFHRSrGiuwJMHJ0BoNUlDFm3Lq/HGn3wScZ9qChEOb62yOYse2TYLehGAS9MUr7SyIhHzNAVb01KFjbv1SeWclXbNwamH1eGrZy/ByuZKx/VcXF+Bq05fVPgdLgDqK+J405omnLe6EYPTOXSPZzA2o+JVizwGNQMddSn8/G2roECfXJY3VeK1S+vw0N5xnL60Dp86daGZiqpOxm1MCwDEiIozezfjzN7NUI6sRexVJ9v+fmxHDb69fhle7J9GXUXcxgICsN8LAU2+zjv4CO477kJ0TeTw/uPa8DZGVwMApx1Wh5ufT5qBRlNlHMubKvSKEwBv7H4cD7Uda4oC1y2oxmUntEMEGvRtH5jG3duH8fiBCVywthnHGXT40vokllbkoCgKTlhYgxVNFaYPzEXcfvFQFAXvOLrVfJtWr/kvIDsJxONYN7obX3/mR2j/jy+jwyXlp6gaThh6Wf+Fe6Ziij7pvo6ZiMnLvSAAVmcH8a0tP8WoFsP2j34Lq5d32CuzSmB6VlcRxzVnL8Ht2wahKAouOtJesVeTips6JgA4rLECX7p/H9IqwfFcKjMQjADg3K7H8Jclr8NQRQMOb62yCd5NOOzgg/vUxGMK4nBPORONKYmvMLYdxPSM6c+kP59OBvVTp3biKxv2Y01rlb3cmd//bNYq75XVNHMTVjDiZBcW1aewuqUSOwZn8Kdtg/jAq+xKcOq+2lqjn/5PvqYT/VNZUydCwf5+9PAutK1tBmIxw9ch/D5TESdFSZiREvo80MohKgZkoSiKOcnMRSiKgtbqJFqrw9GsMS7w+thrOrF+dRPWtlX5a3dYxZzLdY3HFLtfiG35EEGqcQ8liYpvva4dw6jAYXxwY2zvoiNbcKORqz9hoV4VQ4PUI4d34bTD6tA3mcU7jm7BSYvcq2Yo1rRWYU2rM3DX/vcbwEvPI/bNn0Kpb8S7j2nF9f84iFctrHEIX31Bn5F4HIjHcdToK4h5zQ22ZyqIAyvj4qwADdlJnNwWh8LfL/SaJJI6CzBLz2sipjjSo25Y3VKFr56zBI/sG8e5qwRshh+Mc5HScvi3HX/BL46/BJcc67JtLkguqB08GxgECUbMRnlZ3/L2BbUp/OStKwXb5NZvs4OXwcicw2RGNWvQj+1wTmCKouA9x7Tiqw8cwN+2j+CCtc02qpUKWOnEUVsRF1KeNN0DAGf0bgbi600H1iiDxGENFahMKJjJETRXJcxuvEVHlA6jRcCypkp8/DUdaK5K+PppHKqoTMTcgwceefamcauyEm/L+nttAqirdR84z1zegFteGMDgVA4nUobIWL9CCK46fWFhjLcOvKIP5P09QH0jTlpchx+cvxztNRGeK/qMxGgzzJw3WxT2maKTUCLJdP72MD1LJGY1GAmLtW3VpkNzaJgmkkm8ZmALTl01AqVDrL8raqM8lUn50EAgl3MPNNhrrub0axl6m9zxZDNlw4xIO/gI0HuZ6PnWNpeB5/jOGqxtq0JWI/jjlkHb36iA1W1ZivaaJJY1VqAlO4FTBl7QBwjFmkRJyIEiHlNMD48j26sK6oToCdukU1pr6devbDTz0RJ5It/eNOzyvl1qg/diScYVfOXMxfjwSQvwmiW1zm0VaoKlb8nMuvWAP8KwSvfJYEb0zwK0k2eX9YKNGTGeey87+ETC/vscBOnaB+22X4BMcA0y6b1mTL7E697jz20hmRF2XZUMk+Z2Pdn9jLofXsxIiTUjMhiJAK8UDYWiKHivQf3dv2vEbJSWVQlGjKqE1mpvYkpRFPz3+qX4/iu/RU1uxtYoD0CkQZXqUs5a3uDzzQIibIdRibkBGzMSxQ7eP80j/HuAbS1rqsT61VZpuz0gLlB/GjohFCK4cTAjcA3QCCHhdVgqkwYy028eXXvjSWPVZdrLJwDIfX8Gufd2kCcfsv+BMhI0NeI1sfPHX1BmxFi3olg9iby2wX4etVkefzzpGWs/KmSaZs6BKvmP9dEYrFtQY2pHnuuZwtkrGjA0nQWBrltwlJEJkIzHEMsZBkBMozwAkSaAN6xswNkrGkxh4qygGG+lEiUFIST/NA0JMaHmy66FSQkFBR3EC7E+UzMSs5gRtzd2fnsBzr2pdQiapjHZmTn8vNI3/hmu8SI/+XrqNIqYpqHXJJ4wgz/zc1HKhN2XqMEIf0+xv0tmZG6hbyKLA2O6q+O6AALQo43vUPv1fqOSpqVa3G9BCPZthQ1GInQgVRRldgMRoGw0IxIFBB885NMoDwiXpomUEgrBwgQFfcMuxD2tCZgRN1aC/zxymkawHKsZCbruMoXJ6jh60Ri/p4IwI0VM09D7J5Gwgj/AIwgtQpqGhQxG5hY2vqLXm69tqwpUZ08rOGjNN+3m21kb4sLnmIEkzzRNSRC2w6hE+YN/q86XGQkhYC26WDYACCGFTdPQdcQYzYhb515+sgryTLFv4ZQZ8dKMxOd+MGJ1hXZhAyj74KkZYdJbQHHSNPEElFjMGttVF9ajEGkaek9VcNVeqdTsaQhdIIOREFA1gvsNF8A3+hhTUVAzpf2jGYynVTxxUDdF4q2+vTdMKVZmIAHmzsTOPOxePiAScwj8dYyiLQgRIJCwGgnHtlTxz1FR6LQPnSRsk5LLxMfvf6BqGmviC8WMzJUxRgQzGLHOIyFEkKbxmNjpOihrkCughibHjOuAFQC6BUdscBo5GKGsUMo+l5S4kgaQwUgoPNM9iYGpHGpTMZwqsBwXoaEygUVG47enuyawrU9P17w6gCmVCZV5q5mTzIjUjMw78JNUJGaETZ3MsTQNS5MXVDMSZ1iJAJNS0O0bY4jCClhF14z1GQm67nKFiBlhAzzT2yNANQ0NRrwCl7Bg2SrACkrcUjDsvmcjMjTsfZZi2PmkDEbmFO4zWJGzVjTY7Hf9QFM1f3hhABoBFtenbD0bfMFE0MpcD0bm8puWhIVCOHWGCTBClPZG3RbRNL0U9KmH/dfHTkqFuKdZzYivgDVCmkbErgoErCYDNR/SNEQUjFg/KwE0I6buhPEBKRhYHQ/7fxBGLGpQxDJkbAWPZEbmDgansnjSSLEETdFQ0GCky7CoPmlxSJ8Lt5t2rgwUYd0iJcoffEBQbM1IvgFtEGbkwB6Qe2+H9qdf+a+PneDyfA5tqYN4zN/YkA9SgjxTNs3IoSFgFaVpbD+nQlTTmMxIAdM0rBEdYFXUuDIjzLazeaZpYjEgwTIjpRWvAjIYccWLfVPYbLQgB2B26FzbVhW6RfwRXA+YMCkaW/8CerMqPoNVuUFW08w/OKpp8tSM+AUYBRWwuuwrLQHNiBtc2sBOGPkyI+zyNp+RoJqRsMxIENOzeZqmyQmCES+2wxS70mAkF1j3RnI5kGlnZ2nHvlAWyoMRI5pmv16Rq2kY5otN05TYYwSQPiNC/H3XCG58rAcEwKdO7cSyxgrc9fIwAOCdR3s3wBJhUV0K9RVxjKVV1KViOCJM3wr2xqQ3q/nmNEcMiWQ1zfyDQ8CaZ4BQ9NLeAExGzrDFDjLQMwJComke7dACQOWCkYSPZsRR2htWwEqraQ4RASt7PVnzt4SPYBSwjp9lDgKyI9p3rwH27UbsP38GpVpQsMAz3ub+CFgPR0VQnswI6/QLlAUzIoMRDn/bPowfP9lr/v7Dx3uwqD4Fjegt1aNYiSuKgiPaqvDEgQmcsLDWvwEZC/amozdrzGMwKUfkm++XKD84SnuLLCrNu5omwLYo9R1ksilgmsa2PFu+71ray4uHQ/qM0PFHaHqmH5cST+j+rPOBGbFpLZjzYE7+AdI0jKaCBK1k2bcbmJ4EhvqA6uXOv4eppuEb9mVz0QJgVsDKVtPIYKS8cHAsYwYibz6iCV1jGTzdNYlXhtNIxRV84IQFPmtwx9vWNmMyo+JtXHtsX9iYES4YmSsDRZl07ZUoIBxpmtlrlBdpWwH0KSRjMCNB3jrVAqZp2OcjFjPTNERTxRNOFNMzW0ogSDXNPNCMeAlY4wl/wSj7fXayDqrXoPeRS1BJHJoRj2oafh/zdWCNJ6xrDEApAwGrDEYYvDKsG5Ktaq7EB05ox2RGw3/cswc9E1m846gWtOfR5XZtezW+8Yal4RekN6aiWEHIXAtG1DzfaiXKDw5L8ijMSAAdh2h7+TIjxGVbWStN49eivaClvbZgJO4/STpMz4roMzJXUsEiGMdCbGZhbJrCGM+9ghEzTWON/cTr+yzotvx6zQSppuEDmnx9RmIxe4CVksxIWWHAaGa3sE53o6utiOMbbzgMW/umcVpAX5GCg7lhzcFxrglYbZoRmaaZF3BoRvIr7fXtQJ1vbxpbh2AfzQjdHptT52FjRvK8p1WOGTHpepf9zFfAaqZ5vRxY56mA1RxPk9b1DWAHr8TiIPGELmANEAgQTRWniVi4+YwESNNEFbASVsBqC0ZKz4zIahoGtG9Ma40Vo7VUJ3HGsvpwOo9CIsc8PBR+vSvKDbb8ugxG5gW4CZCUvWYkQKqQpd/9BvtiMCOxmP7C4SdQd5T2hknTxL2raei650OaRtSbJqyAVbWujfn9IGkaF28TG1w0I6SoaRrm5TYpTc/KFpQZaa2Ono4pOPjBAZh7aRpbWeYcCaAkvFHoappQaZoiub1mGWbEj4pXCxiMmFbwPF1fuK69Nhdnr2BkPlbTCJmRuPfkT0GPP2Z1Uw6UphFV8PBQLbGwuU/sPgq+a60/YjDCClil6Vn5QsSMlBxUBMVSxnMoGLEZOgGSGZkvKIRmJJQDa54i6CDMCvvGO5vBCNeMTYn5BSPh0zSETdMEKe2dDw6sXqZnrIAzSDVNLGDwQhEoGGG69gKWkDVQMBLVZ4R1YC0vzYgMRhhQZqRNMiOFQyF6mEiUHxzVNPkKWMOYnuUZjLhpMVhmJEyaJu9qGhdmpJBpGjY9Ecj0bB4EI8JqGiYoC1NNE4tZwUKgNA3znaCaEa/9cWhGCi1glcxI2SCjahid0S94a00ZBSP8DQvMLQFrFE8EifJHIXxGZjVNE2BbpUrTmMwIrZbzCUaidO1ltWfmy4xHmmZeMSNupb1J59/d1pFXmsanKso414pnaW+hghHN2lZS2sGXJQan9BsgFVdQlyqj06IKgpG5ZHoWJb8tUf7IUzPisNQOVU1TrDRNcGaEFFLASica+pLhpxlxBPhhNCPxgKW986maRpSmiesdjAHviZ0wrFWCpmkCBALM/UFcq7eim55FT9NQZkRqRsoW/ZNGiqYm6e0vMNtgVfAUcylNE8WgSaL84Ui/hbyuYbv+zkajPJtmxIepKWRpL6cZQVjNSJCqujIUsJKJsaKtG4CYGWHH07DVNF7MhWM5NlgNqhnxWD//WUEErFYAokjNSPlgwGBGWqvLSLwKMJoRUWnvHJjYo3giBADp3g9tw53BxGQShUe+PiNhNSf5+oyE1Yz4ubAWlBkJqRnJozeNElTAWmRmRNt0L7RPXQLt8X8UZf36RpzMCGHH0yDBhS1NE40ZcU3T8C+anpoR7jpE7trLaBAlM1KeGGCYkbLCHK+midTuPAC0P/4C5Pf/B2x7piDrkwiJfIXJDmbE5+2+kAJWl/JyEooZYat78ixX55kRnzQN4T8PpRlhetOUUsC6d5f+/8E9xVk/YB2fa2lvAAGrIE0TKBDIBbiXTM2IMed4VfcU2mckFrNX0EjNSPmgbJkRPq8IzK1gJIrYLgimJvTVTU4UZn0S4RA2zZLv8rZGd+HvIRKkcicXopqGZU7yZfvMVACXpgnMjAQxPWNSAgYzQkopYE1PF3f9gI/pWSJCmqbQPiNumhH/aprAlvSObTLXNyGracoSVDNSVoZnYN6ChALWOWAglu+k5Qb6sLPUusTsgQ8qw07IYdM8hWRGAjmwhknT5Blgs8ZagFVVE1jAGuB8jI3o/9c2eC9H7c+LzIyQdLqo69c34qMZ8Zr8KczgLG6mrgKlhgOV9nKst2c1TaHSNKyAVQYjZQnTY6RM0jQkndYrDkSlvXOJGXFQyoUKRoyHMepDKZEf+Ak4b2bEr7Q3z/5GbB8ct0nephkJkaYpFDPCT0qBTc+8zwfJZoHxUf2X5lbv3jQOAWuRXngyM/btFQMe1TRKPBEwGGEqneJh0jTBHVgDVdMUKk3DpARtolUZjJQPTPfVMkjTkOFBaP/xryC/+K49x0kxl4KRYpX20vMS9aGUyA/5akbyErDmWU3jFjxknD4jZHgQ2sP3g/AMXJF60+j/hzM9820yODKo/59MATV1PqW9nI6haGkaGowUkd319RkJK2CNmKZxOUbCer8A3tU0/Doip2lYB1bmxVtqRsoDkxkV0zn9pisLw7MDrwDpaZCXtzjzioCV8/V7eysHFKmaxnw7kWma0iDfaprZLu0NEszkBMHIX34H8qsfgDz9T/t3C6oZ4app/F42wj5TQwP6/02tum2BGYwIvjtbAtYCpmnIYJ84IPPxGQmkGbGlaYJX09gCFrdgh3/R9BDUOsb6fNM08RinGZHBSFmApmjqUjFUJkp/Ssj0lP7DxKh5IyvS9MwOyYyUFvn2pgmdpmHSLHk7sPprRuhbK6HpDd4Tw1ZNUyBmhJ+U3CaxsGma4X79h+ZW/X+v0l5W4AiUvYCVPPcEtM//G8gdtzj/6OkzwtrBe4whbEfleAg7+CDMGf+i6RUcFaxRHnN9ZZqm/GA1yCsDVgQAZoxgJJMBpib1n+eLZqTgAlYZjJQE+famKaUDayA7eOM7dNB3mE6VMk0T8twbzIjS1KL/Hsb0DAHSQFGQocxIfuwu2b9b/6H7gOCPxn4TAmJW1jA6jTDMiBI2TROg6aKjN41Xaa+xjzSAiOqvRJfjBawyTVMeGCi3SpqZaetnmu+1lfbOZdMzyYzMCziqafL1GSnTaho6eBcxGDEp+BgnYA2cpvE598PGGNLUZmzH42WGMJO1ub0ijDPpAglYJ/WXNWHqxGZ0x5X52qppVHe2LWKaJpADK2W9TQGrR7BD15GqNJYtgAMrZUMqqsrCdbz0as0yQP8UDUbK5HRMW8EIocGIZEbskKW9pUW+Jduz7cAayA5e0CiPDvr8fVxQO3hmwgPM0l5XTRj7dp/L+QZnZNjQjJhpmgDMSJx5MStwOpgQUjjNyOS4/j/HkBJC7Men5vS3f5GAlf494XwZJSxrZQpeA7A5YXxGeGZEWNprfFZRqacMI/emYY6/dQGU178VaFsQbV0FhmRGAAyUa5oGsN5qBALWORGMFEszkpPMSElRYGaEhNCM5FvaK3pu9DJ6gWumGYxw91kxuvbypmdu9H7YipchXTMSNU2Tz/GRiTEn65DLWgFOvqySYX5oEx+L1msyI4y3BxuMuOpzmDRNVGbE2DYZHYZ643UgLzxt/04Q0zOamqNsRsRxjzACVkVRELv4A4idfX6kdRUaMhgB4zFSNswIE4yMDOn/i0p756KAtRDqeVW1jl1qRkoDh+YjZO4/pGbEpluIojMgPsvzgzuvSSqmZoR1+QSY3jRuwkfj8yT1AgmYpgkiYC1gMEL27ID26X8F+ePP7X+YmbG+k29pLw1G+HHAEYwY10ukGWE/58GyVpF70xjByAtPAc89Ae2Bu+zfoUGIV2kv3f/KKvfvBAHvsFtGkMEIGPfVsmFGGM0IpSEZ2lSZS2maYpT2su25JTNSGuTLeOVV2lt4ZsTmMQL4pmlsef1872nTyyJYb5owzAjJpK1KIEMzorgwI7aAj01ZRA1GuvYBRAM5sMf+h4wVjOSfpgkYjNDUCpsaiTHTn5oF6dpnOcPy6wnbtVfkM0L3kYp3OXdtxcv0zNSM5MeM2BxYywyHfDCiEWL2pWkrEwErYdM0FDZmZA4JWKM09fJdJ/MgSs1IaZBvNU3Y0l5S5GDEzdRsFgSsVnARsJpGY97uAe9giLIiqQqgusZYP32Z8WCnCpGmEZXWApZ4NZ91U7ilaXjnWJ4Zicf1oIwe566XoV3zMZBffs++HOvAGipNI6imof/TYITtF8T+71lNYwUjkUrcebffMsIhH4wMTWaQ0wgUAM3lkqZhmRGKedMor7DMSGS6UiI/0IGQDmpzyYE1SDDiYEaKqBkxJgjFCEIUv26yZqqBMiMe537I8hgxGRE3B1b2d/bNOaolPD0v/BjAsg+FCkZ80zRUAyQWjZJdL+r/D/aJ18OapAUJRrJsmoYGZVww4tCMeFx3eo/QNA0h0c6dqNdZmeCQD0Z6x/Ubo6kqgUSs9OVNAMTByFytpnG8AReAGWEDEMmMlAaEGaSBAjAjfsFInr1g/DQn/ATjV02TK2Sahntb9WM+QzAjxCzrbbU+dBOwstuLxfIfZ9yYEVuaJrpmhGQzVnqNv34uwQhxVLAY5bS9XeLlbGka47thG+WpHLvmkqbxTAPxaRogWqrG7M1TflN/+e3RLKN3XH8w2mrKKFKcFqRphMzIIWoHb7NalpqRkoAGlXTizLtrb5GrafwcWMOmaWzMSIFKe4NqRsK4pA5TwzNRMOIREBYiGHGrmJkpUJqG6kUA5/XzE7DyTQlpMOKwIqCsVczU6AQKRlhdm2m4xqdp3EzPPBxYKyqZbUQY+6SAtXzRM6bfGGVjeAbYS3sp5mg1DXG4RRaCGWE1IzIYKQlIiAlRhNCmZwEa3QXdnjAY4ZkR1Vbu65iACsmM8BNkUM0IbXTmFZzRvjTNIZkRpQDBCG80ZoAUSsA6xQYjAdM0bt4e/T3Gci6+SLGQaRqRzwj932RGXDQjQgM35prT6xdl7JMC1vKFxYyURzBCCAmepuEn+nJE0TUjMhgpBYg21zQjIZkRNadPHvS4+Dy+KnjzjQo2FQAEYEY4et/j3JuGZzZmhL7M+KRplDyF8oEErHmcOzYY4QWdbsyIyUYYx8YHAAVL0wiCkaBpGi9mJJ6wtEJROvdKAWv5ondMfzDKxn01kxE//GwwMpdMz4pRTSM1I6VHoZkRvw7UeZf2shOVYFv8W2Yu591fRNAojxACsvtlq9Fl4H1z6U3jV9prdtb1OHeeaRreuM5aj1LMNE2hBKxsmoYQzhXXjRkx0i50QufTFa7MSLhqGiJkRqxUEcll7Z4n7P9e1TTxuBWMeDAjJJOGesPnoP3+py7rKZP5joEMRsbLLE1DUzSKYm9eJNKMRFW5zya4QYEURDMi0zQlB53IoqYMHT4lfmkaltkohmaE85dQuWDEkaZh/kbPxY5t0L55FchvfxRu3xy9afzSNMb+JyKmadyCDJVjaPJNB5vMCHfuCpSmIWwwAtjHAlfNiAszYn6PLwlmrk0YnxFRbxr2MzZg5cS04mCESa8ESRft3QXsfBFkwx2WOJddjxSwlh9omqa1XASs9CatrALqG82Plbla2luM3jQyTVN68NU0odM0+XTtjRCE+9nB871NfJkRZ2kvTYmQgZ6Q++YiqnS5twn/Ru1y7kl6xkplhKmm4YORfNM0/PUqlIB1igtGcl7BCKfb4AMACrdy51jMNCUL5sAq8hlhzsP0pPVzkDSNxux3kDQNNboDQB66j1mPFLCWJbIqwcCETvOXi+EZ0oZepKIKqK23Pp+zpb0yTTMvwQ9qodM0IYPUQlbTiN70RZqRrAczIkjTmP/zbq5+MBkJY2Kk5ZuZtPj7tMLD79yz2rOqautn12CETxcVqrSXW75Apb1wMCPMeQ/KjPCTskNw7xSwhq2mMdfBfjbFBCN8bxqhHTxjjEe/75WmGR+1fn5kgxVASQFreWJoOgsCIBlTUF9ZJheHMiNV1UBdg/X5XA1G+Ie7IA6s9gfdtbupRPHgMD0rdmkv6zOSpwOr6H5xVNPkuIqIANU0dBthA2TCBSMVRjDCW5Ob+8KZnrmde4YFsLWId+tNQ3+nwlWvHjZB4Gp6ViRmxDNNw6VK+ADAXM4tTRPSDt5mP5BzfkaDEUWxxnNGM+JwVxUJWL0YGoYZwfgo8Ozj3HrKZL5jcEgHI/1Gt96W6gRiSrkYnllpGsUWjDA3T74q99kEr2spSJqGFxvKVM2sI29mJI9qmiiTY1AHVjoBq6qPZkTw5mv2IHEJItzAvvUClpdENmPvF2NujxewugRnvM08hV+aJl5oZoQ7d4USsHqlabhxh/CpEr45ndv+MGmaUHbwgt40RKQZobb07D6x+2nuBqNd8WqoRzFuBCOG7lDbdK99vTJNU14wu/WWSVkvABBKrfLMCNu4ag75jDiZkfz32UGTShHr7MMhYJ1NzUgxfEaMYMTsipr1ZkZEdvBmmiZkMMJONACQYoytROtyCFhdzgdvpkbh15uG/p1OkpGDEcpGcCJ2Nk2Tx3jgFLB6pWl4nxFOLGwu5+Ez4qPlscEnTUNoIMU0QPXsImxL0wRnRpTTztGv44vPgYwMOQPfMkL57dEsYqDcuvUCwLQRjFRWAXWsZoR5aOJzKE3Di/MKbQcPOJtkSRQfZprGElGGatwVtrS3kI3yRBMgHdjZFu0uAlbiVkZK7/XQmhFOq5FkxiN24ua/n/Bhpfggh8LPgVUpMDPilabJJ8XqlaZxpDl4nxHKjHBjv2s1jZWmCaYZ8ROwGswIG4CwY7yjFxKbpvEPighN0yxbDTQ06z+PDtuFsGWGSHt0zz334I477sDIyAiWLl2Kyy+/HKtWrRJ+98EHH8T//u//2j5LJpP43e9+F2XTBUU/ZUbKxWMEMNM0SmU1UNdofc7etHPRZySeMEykClzaC0hmpBTgq2noZ0rAXDSfvvO7L/JO0/hpRjhmxCtNo2lc2ofY9zGbASHErtOAUd0iAhewK7GYLmLNpMW6EUdvGpfgTBVcIyBANU3AHjl+KLZmhGdGwlTT8M3pzOVc7kvGd4XksvBN6otMz1zSNCY80jS2EuMEtaX32A9DwKrU1oNUVQMjg3oFTxkLWEPPwo888gh+/etf44orrsDq1atx11134frrr8d3v/tdNDQ0CJepqqrC9773PeHfSokBQzNSVswIk6ZR6uphDhc2Aesc0oywA2cmXfhqGkAGI6WAJpjoNC34IOfVvt5re0G+G2V5ymZU1+j/e/mM8CkbOmHRCYMQ/fsMw6E9sQnkpu9g6jNfB9YcY1+er6YBdN1IJm2fuM3vcwLW0MyIj4C1UD4jzHmxBWfpwqRpMDmu/59I6tcqQjWNEk/Adie6OrDGAdpINWw1jTAYMQSszEumoij6fqmqcxtswGqmaQKU9tbWW5VU01Pi57ZMEDoYufPOO3HOOefgrLPOAgBcccUV2Lx5Mx544AFccMEFwmUURUFjY2PgbWSzWWSZCUZRFFRVVZk/Fwr9jGakkOvNCzNWmkZhmBElYe2jEo/pDxDRfPfbXKZUx2fS+foDpAjeGMNCUVXbAKLQTpTlcg0LjJJfQwEUQkBgH8wVBN9HR0qHlqu6Lc+V9oY+Fxyz4ljeCDyUyir9eBzVNKq1jMA7R1EU85wAgJLNQEkxpoW7XgI0Dekd26Acfiy3PC3VZcSMFRXAuLEefl+NCVxJJI1xwOV8MIJUezWNxYzYPtcsHZDCVnkEPN+O+5Q55wohOuMD2HUwqv8YJgIhxKpIaWgCBvuAXNZaFxfkKPT6MQ6siqJYwUBtvT6BG/vMX2slHjODOpLL+e8zJ2BVFEVc2hvn5h4jGFE01f65uR8JIKlfd8VrP6hmpK4BSlW1fp/Q4M1Yj2jZUo41oYKRXC6H3bt324KOWCyGdevWYfv27a7LzczM4CMf+QgIIVi+fDne/e53Y8mSJa7fv/3223HbbbeZvy9fvhw33HAD2trawuyuL77xljocHJ3GcYsa0Fid8l9gFjCoEEwBqG9fgOpVq9FtfN7e2YlERycAYLyhESMAqlIptHR2BlpvR0dHMXbXFyNVVRgHEK+ogDoOpBIJtAfcZzeMVVVilPm9ub4OQOmOcbZQTsc3XleHEQCVNTWgbhYd7e2I0TSHD6YaGzDI/J40JgW3Y+xSFNAQoKa6Gk0h76EDgBkoVKZSaOWWH0zEMQWgsrEZ0wDiBGisrbH2Uc2h01hGHR0G42mJZCKBjs5OjNXUmPflgqZGxFus8WoormASADTNcYwDFSlMA2hoakatsY3umlrkBvrQXFuDSm5fe2IxZAHUNTVjFEBMUcx9Y5EeHUQfgHiywvb3kbo6jMN5HtMj/cb3k+js7ERPqgJZAC2NjY598AI9vqGqSlA3jc72NiiGf8rBbBY0VIgpEO67H7SZaRw0XkJSbQuQGexDY20taox1zQx0oZ/5fl1NNeo7O7HfWGZB50LEW9owVFuHSQCpRYch8/IWfV8XtJseLgegB5htCzqgJFPohp4e8XsWD2jWC1OMEP18GtcNACqJimkAiQr7tTmQTIFkMmhrbkKS+bw3HkcGQHNrK6Zq6/Q5oroKdYJzp6VncNBgnzpWrcFQUwumAdTFYN6fHYsWIUZZQAFKMdaECkbGxsagaZqD5WhsbERXV5dwmYULF+LDH/4wli5diqmpKfz1r3/F1Vdfje985ztoaWkRLnPhhRfi/PPPN3+nUVp/fz9yQSiygKhTFJy5ugM9PT3oHi1A+qAAUIf04W88q2Ji2nqD6BsahkL0NwttQs+VTk9Ooru727kSBoqioKNDP8ZQAsMCQR3Tb3/VuIbp9IzvPvtBGx62/T7Y24OFR6wr2TEWG6W+hiJoo/p1nWEYzJ7uLl3rFGT5wUHb71nDldPtGFUmZTI5MYGZkPcQ60UzM+V8btQx/U1yxsjCq5k0hvuZ6SyXRVdXFxRFARnh9t24p7XREfOz3gP7oWSssUodHqIH4jhGdVKfskcnJjBu7FfO0N4MdnUh1m7f15yhIxk3xO5aLit8pkhfr75+ENvf1Sldr8CfR9Lfp/+d6N/PGedscKAfsQDnm79P1QlL09F98IB5b2iM+6jbvvuBDBnXJp5A1ghyRvr7MGasS2OvHYDx4WFMHDxoMh+9g4NQMjmoGf2+yjZaDrXdB7ugGCk2et/0Dw5a7TkE19Cxf0zKSMvqx5ibtkzopo1xPgfYjp8YKbT+7m4oMesFOWdoCYfGxkwB7djQECaMZcnMFHBwH7DicGDYuD/jcfSMjUMz1jnWbc3RPQMDUJKMF4mBYow1iUQiEJFQdOXmmjVrsGbNGtvvn/rUp3D//ffjXe96l3CZZDKJZFKs4yjGYEzCVgIUEbS0l1RW6W8SS1cBE2MgtXVmyoNQIZWmBd7vkh2joMNovvvB1/kTI99fTtexGCin4yO82BHGwB30fuSEgnR9rsfImZaFPg8MbS96boigtJdwVVpEVYF43GEdD2N9bMBDOH0UMQIIum12+3Q5EotZnxteIyQ97WqARXyeKcKIHu1/V4TLEapdUYz9YLqDhznf5vGx5yOnWttj0zQhxjDbNmjKoboGJKFP2iSTsdbF319c2o3E4vr1Wb4a2HQvcNTxwOMPWt81DciMc61YXXuhadDUnKW9EYETsDoqsGhAFk/Yj591eWU/FwpYrePVfvtjkMceQOzKr1pVmNTBm97TrEW8EvN8Vksx1oQKRurr6xGLxTAyMmL7fGRkJLAmJJFIYPny5ejpCdm/4VDBNK2m0W+g2Bf/S8+rsiVoc6maxvREiGiOJYJX0zKJ2YGox0Wo0l4Xh0k3FLK0N4jPiJoDsgKjs3hcIC4UVI3w/iC0zQPvu8MuxwpNqSW8SMDqqKbxE7Byk2bMqekQfj/fhpzs+WDLnm2TbMTxwGCTUFMLxdBQ+FbTsMGAcd/GTns9yKtfC8RiID//H+u7FALTMwCGQFmc2ieaxrUL8Kim4U3XzP40Lu0HWCdY5v4k/QZDsmcHlOWr9Q9pMFKlp2PIhKUZcdwTZYBQe5RIJLBixQps2bLF/EzTNGzZssXGfnhB0zTs27cPTU1N4fb0UIHpwKpTmkosblKGJuaS6Rlf116IYIR/UGV/mtmHqLQ3zLV1NNorXmmvw8VUGIwYExmtPFBVgddD1vqbbQNcaS/g9BqhzeE0QZqZNxsDoFAXVpFnSdBqGjfr79lulMfuC++bEjXQocxITZ11HvyqaWzBiHVOlIoKuwmYqMNzPAbP0lvbtviyXA87eN7vwy0YYcdROh+wwRctfOjtAqHuq2YwYgTYk8bnrFC6jBA6TXP++efjhz/8IVasWIFVq1bh7rvvRjqdxplnngkAuPHGG9Hc3Iz3vOc9AIDbbrsNq1evRkdHByYnJ/HXv/4V/f39OOeccwp6IPMGZmmvhxBwTvWmCeiJEAbSDr704B1YgXBBAltiqKrFLe0N0geHTmQ0GMnlBP1q6BuuM03jWC9vCW8wHEJ7d4NFsb100P40ItMzWvGRSJjVNEKELe2djWCEZ3oirtt0MK2utRgKv940LsEIAHvKhaZmWD8ZJW5fJpcF4DJGC+4PQsu9KVyZEWMbbo0Z2dJe9nhoer+vC8rSlfouc8wIKDNShmW9QIRg5NRTT8XY2BhuvfVWjIyMYNmyZfjiF79opmkGBgZsUdfExAR+8pOfYGRkBDU1NVixYgWuu+46LF68uGAHMa/AOrC6wRwk8nAvnC1o3FtcIdgcPviQPiOzD7OpmmEGpWkRmZEkgIx/moYr7Q2FQMyIEYxUMGkat340bh4QNmZEHIwIj5N/kwWCpWniEdM0fswInZgVS5sW6T3aFkAWNhih7qtKdY2YKRAxI4z7Ks8MmKXMmia+nrEYlFjc+g7PXLBw67orSv/wzAinVbEtD9iDEXbco8FNX7dpeEbbiSiVRmkv1YyUofsqEFHAun79eqxfv174t2uvvdb2+6WXXopLL700ymYOORBNs3LLXlUJgjcWkeNjWUDlHrpimJ5JZmT2YXpSKMakpTl1IEGW99M9mN+PnqYJE4yYngyA9SxS5IKnaUgmY5/ATWZEEIxM2CcPAFZ/GpEDa+A0jcBMDXAPRggXvOTJjBCR6y0NRlIpPQVlsAahxy7qvuqWpuHvEVW1Ul400OMRixuBhuZcB03jxBOA5hM8i4IRTRUHMG5pGreA19YoT78fCSHWvTo+CvTrVVRWmsaYS2hqqwzdV4FDvDdN2YF9a6jyCEY4Aat20/9Au+ZjuoK/3MALWIviwCo1I7MOk75WommY+DdDvwnPlsePXknjui36lskykvxbvNnfJEiaxronbZMF3401l7P0A7VMMGJqRoIIWMXnwwx8eFreLcjg3Tk9ghGiqiBbNoNMTTr+5lgfu8/0nLIvW1HYUp80jSMdpuYstsotGDGrZTjreMBqcxCkY64o6BC5qkJPtdmQ8BGwihxYs/bgiOx+Sf+BVtXQNE0Zu68CMhgpL5j9ChLOBk4sYnbRH3nucaB7P9B9oMg7GAGOduf5p2nMVtz0bUqmaWYfLKUfpbsrH6SGStMUgRmhZbzsJDnDMSMiW292fW4C1lxW/B3Aos6VGFBTa31uakZEzAhfoebWmyZimsZkRtzFxWTzI9C+dy3In38r3ja7PnZf6PHQCZL/XlCYzEjQNI3KBCMuBpd8mw0uTQMgWOdeOh6xQY+miu9xPjCgzfjUHEguZzXlEwQjpsUBf58O8MwIl/KXzIiEL8xKmipP2lLhu/bSG5apIy8X0LczxS+/HQb0eKkXg0zTzD4EDcRCsV6Em1A97gtCiH3doZmRIAJWJzPiaGzHTwy8DspNMzJjrYfwExJN0dTWWXbpgJmmETbXE+iwxN4sbtU0YiaLsAEm4J2mMYy1yOiw82/89pmfzeNhmd8IwQihPh1VtQGraVR/ZoTX4rH7H+eCEc9qGuM+YYOebFZ8j7uV9mYy0K79OLTrPmUvFRakacx5g4NDwGpuozyDkfJUshyqmLaCEU/wg4QxSJKJsWhCs2LC0e68AGka+rBXVutvBTJNM/tg0zRRfG94nxKvZfm/FVEzglTKqvDh3zjp4J9jJhsb6+FSTcOmWvhASCReBaw0TZCuvYB+PfgXGHYCYxGUGfG6rqIJ2/EdD82ILRiJIMQ31qNUVpkvI8SjmoaoOSiBgxFBcEnPRZA0Df1bImndS24p9DjHgNNAoa8L6D2o/5yesYuW+TQNf59SUA0Srz8sUwGrZEbKCTSv7KUXAaz8pabpzAMdnFlTm3KBSccXsJqGf4uVaZrZB19NA4RkRqiA1UeEKfpb6NJebrJzTFRMaXGywpoQXNI0JhNHtQpmd1qXNM0MG4xw2x4XiFcBs48LrxmxOZuyE5mXay0fjJimZ3n4jNB9CHrdeM1InsyIuZ6KCpc0jbMahQTVjPDHFmMaDZrf8QpGjP2gwQjgEYxw14YGO71Me5X0tLW9eIwJRoztTLsEIzTApQG22zbLBDIYKSdMB6ikAex0Ihuhl2GaxlmGWEBmxPSEkMHIrMPGjBRZM8JP4KFLe10mXQqWWUsmrUneTcDqVs3CrpddJ1OV40zTuDEjLqW9bDDPMiNC9oKyT/wwL+5sa6Xe9MlKCRSMRGNGbD2MogQjNMCrqApYTRNAwOqWpmHTZwlL0+EK+rdEwgoE3YIRLk1D09mkjwlGZqZtTKLiSNMY9xfvCGvcU4qi2IM/GYxI+IHMREjTsMHIZDkGI7zYrhCaEcmMlBzmW2PEaho+TeO1LM9s5J2m4dbHTmKJpHWvOtI0nJMmndREaRp28kn7p2mUOi4YoaW9vAMry77YrPjdUymKq+lZQGZE5JJqinlDBiP0vLBjXJQxgTJGFZVQ6CQcUMCqeJX2ssvy5wOwAtUgaZp4gtGABAtGrDQN0zyQrVhietOYpb103li8zPpeZZXdRI8N/qSAVcIXxuCn+KVp2GCEjdDLMU0jaJSXN3IcMyI1I7MP1pkyimaEt4MvapomIDOSSOhsAN0n19Je43862NMGlm7VNMx6HCWnIo8RgNGM8CZhzOTPa0Z4uNnBxwKannkxIyJjMB62cmwuTVNRmZ95I7seeh08HViDMCNcaa8ozRUkTaMymhF6jK5pGpfSXva6s8FIPG4JY+k6adDc0Aw0GG1WeKZNMiMSoRBFwMp2oiznNE1Qc6sgMB52hbpluqRpyNZnoN54naPlu0QBwDIjboLIIMub1tbB0zThHVi9NSPmJEbfsOMuzAjfY4R+X5CmIYyA1VYRw/uMUM1ILR+MuNjBs8uz5f9eAYOLgNWR7ooiYA3LjAiDkXBjAiGESdNUelfTsPcXnbwr/DQjHNMlSNMEE7AKmBG36hm33wHL+p7uIy0Bp+XNM0xz1bZO/TM+uLUFI1LAKuEHhnr0BDtIsBNxWQYjfAlnMZgRcTCiPfg34LknQJ5/Mv9tStghMj0LxYwYywdJ0+QbjLhpIyhMZiTpuU+ET9M4ghGx6ZnNydWtmsaRpqGaEe6N2pUZ8dB1BCztpcehhBKwRg1GKqI7vOaYMtmKSus6iNI05t+iaEacaRpF1BeGA7GlafRzb4pnK6rsfXD8ghPAMngDjGDEuFcmx43AzOpnpiwwghEHM1JjX0cZQgYj5YQsQ+95gc3Rsw/FZDmnaQJUTQQFrxlxE7BSIyupKSk82GoaxUUQ6QU68QXREjlsy8NqRrjl+bd5nhlxc8Xke9Pw1TRRfEYMZkRxS9OojPEVYJ/84z5pGpHmAfAo7Q1hBx+kmoY9VuozYgYElbaqQC+QmSmoN3wO2l236h+w1UkVFeJeLfSaJAXMSNjS3tBpGlpNYwUjNmaE3X4AZsSWplFiQG2dtX/Tk3ZGfeFh+teaWm2rUOZAmqY8+ZpDFexN7AU3AWtZMiNFSNPQYzZEWcRNM0IHQ1ltU3jkzYw4GTNhR1vRekNrRnyWp/ePmabhBuvKKl2P5UjT8NU0rIBVrBlxdWB1E7AC+kRmVh0xWhs2yIiQpgksYBUGIzn7NkRgzjtRVb2Gh03TxDkmwg0vbwF2vggyPAj8yzstpimVghKLg5ilvYI0Db2mkTQjgjSNW+8YFiwzwlfTUM0HPQa3wJcFZUbicb0yJpnSz196Rr9/ZqwqTOW15wIAlFefbl+HFLBKhAJ7E3vBTcCayYCITJJKCUc1TSFLe/2YEeNzyYwUHqbYUXGvzgiyPHuvBw1G8u3aywcnOS4Y4ZlJtpMvYD6nClNKSTTNo7SXFbCq9mWo6JzXjCQSjPhRUI0Ti9tdmsOkafx60/ACVo9KnaiaESWEZoRQzw066aYZdgUQ9qaxghGWGfFrlBez76uIWQqtGeGDET9mRBAoUGaE/VuNwY5MjNuqMJWqasTeeCGU5jb7OuYAMyKDkXICr9J3gxszApRfea+jhLOAmpFKb82IZEaKCNaTIgozwgepgPsbsp8A1Q++zAhN03CaEQozHehS2kvXGaS0l528pyasfaPUuwFFUcQurLyrahCRaWBmhAte+FJXFlFNz1h2ImgVVr9R5jozZW86SM8PbwLGrjNhMSOBTc880zQujexYUIG9yPTMLxgRMCOmgJXdD3q/TI7bmBFXSAGrRCioYZkR1RmMlFt5L28Hn2eaRnegNB52X80Il+OXKBwow2WrpslDwAqBnsL8gw+z4QeR5wS7ukyANA3gbnoG6MfjWtrLCliZ71DxalWNJYxkYYpYBcxInE+liEp7Nft3KdwErIRjAryChUA+I07NiE2f4xXssLtFmRFV1Rkns/OvcV0Y9oPwQVIozUiANI1bV10WdDyypWms8nHb9gMJWCedfzOYETJhBSOKVxUmE4wokhmR8INpM+2nGaHCL6JZOhOKctON8A6s+QpY2UHAz2fEreW7RP7IVzMiZEaCakYiNspzm4RNzUjSuU+AlabJcfcT63ipafaJ2aW01xZwmVbwnF6EQmQJr3Jv615l1fTZUwqvGTGPI2gVFN1v1p00qGaENQCbmbKCEXp+2OtAr40pYHVqRtxNz/T9cQQ0Is2IVxDmm6ax9lfxCkbo+EaDEbaqh1bLTI5ZAlYvf6pKmaaRCIOgmpG4e5qGlFtFDXWBNHvT5JmmYQMLP2ZEBiPFg62aJo+uvSwz4pqmKRAz4la5w2tGHGkaq7JF/76gKytRPZgRFwdWN8MzCpqGYFM+jlSKYv+cBc+iUPgFI2FMz7wmZfY68ecungiUpiHZLDDUb30wPW0Fd/T5Z1kl+qyLmJF0UGYkQJomTKM8wKOahgsM2HvPqIyxBKxOZgQTbJrGnRlR2NJeKWCVAAAyMgj1yx+Bdv9fnH9kb2Iv2DQjZc6MqNxEkG81DTsIBNaMlEeahhx4BeqXPgTt8X+UelfyBytgnW1mJKqAlQ78fOWOcf8oLqW9Ci9gFaVpNGK/t3NZK7hyYUaIW8deCpFmhNeBKNYxOeDWtddPwOqwg/fSjAQUsJrBC8P+BrlvBnrsxyZgRhS2soiyXI5qmgBpGodmxKM3jdcLjq201/i+rZqGDUa4sZ659xQzGBEIWE1mZNw0PQuuGZHBiAQA7HoJ6DkA8vQ/nX9TAwYjikVvknLXjBS6UR49XiVmOSm6pWl4Wr3EIC89r1POzzxW6l3JH2zqIx/NSIxZ3u0tu1ClvW6BD2d6pgQVsLLpAaI5958GyW5de908RiiMSUvo4GoGDAHSNI7JJ2yaJmJvGvZv9KWEfeHiNRoisN1rAX1iNityGCaAr6gxrrkSqrTX3/TM0dmXgRl82kp7OTv4eMKeJnLrTQMAi5bq/wuDEYMZGR+zmZ65QgpYJXgQL1GlMWk68og8WDrREYyUGTPiR5GHhTkRJGxdU4VdNI3PPN9iZhPGgEwK4bVSYhBW7JgPM6LEzPvZNU3jEFpGZEZsglMnM+Kbpslx91OK04zwx09TNW4OrG4eIxQizQgfYHh1TOb1JQaUmEvwGErAmnP/G78+9vusniLAfWPrXgvoEy89n/S6AM6KGi87+KClvaLz5+LASrZvgfbxd+muz1528I5qGi5QpONkPAGlfaGxcsF+UAHryKB1rAEFrJIZkdCR46he0d/CmJ7xk3C5MiOsuVU+7Ij51pG0vZkSUaqmzNI0gZqLzRWIBKxRfEaCBDP5akYElTu2deb40l5msFYUIGlMHjwbwPeGcZQMGxOQn4CV9xihmxaW9nITUxAvkLCakSCmZ0HuZS5Nw1bCBU7TsOJVAGR6yukzAjDN8lzSNERzCl85mN2N6bkkgjSNqRmxjzdkxzYgkwbZupk7Rq6axpGmcRGwNrc6mQ7mvlQoMzLQa3yg2M8HDxmMSDhA84miN3m2JMwLHj4jZdcsj7eDB/JL1bABGzMZCF1YyyxNE4janiuwlfbm4cDKBiPFStP4GazxvWnYl4FEknkbNu4jEQ1PNGe6gb4N2zQf1nbNZ9VPM+IlYPUSD7tpRtyWMdkqLtDx9BkJanpmBGtmYJgMyIwYwQgNoGamxMwIn6bhBayA2B+GBZ+CEaRpFLc0Da1oGRuxvTApfgJWLiWvtC7Q/1+22qri4vcPsPrTjA7r/1dUWj2FRJgDDqzlmTyaz+DzzizUkMwIYA2kVTV6n4IyrabxbXceFEzAZgrXNM1evUDBU8OlBu9fMJfBVtO40f5ecEvTiAbKQglY3QzWeGaEnSDYigj+2U3QihDNNU1DNI0rzXUyI36aEaFpmplKcU/TEBG9zy6Tlx18SAdW3hOJZQ2CaEYWLAJ6DuiTPtux11yfT5qGRUDNCPFK0/BjCg2QxkaA1g7ju87SXoUr7eVZCmX5GsS+9kOguc0KNMz9E2hGKLzEqzCCKGohL5kRCQAB0zQBq2kAKxhpaNL/LzdmRDQR5KOZ4L1YjHMlZEbKrbTXbE0+D9I0bDWN8aYdKv1GGGbFZEYCpmkKLWDlnzt2sE4knBbg1HQvzqUaHGmajP6POS82XYxbx14KL2YkSJrGt2tvwGCkENU0as7uicSfOwFINgMMD+i7vHSl/uHMNIiouzmfpuF9Rli4OVw7SntDmJ4xzAjxapTHa0YEL55K5xI9RVfJpV1EdvAUXnoR8ztGwFKmzIgMRmYbfLMtFoFNz5jLRhmBxmb9/zLSjBDWlTJID5Ig4NkjY7AhHDNCNNUabMuOGZkHwQhbDZOXgNUqy3T3GeE+j8qMsJU/ojSNyA4+mbTKOXkNki1NQ8RpGla8ymyXEOLvM+LpwBogTSPyyQAYbxI+yOMrdYJpRlyDUDaI4VPKbDmu233Tb5T1VlUDbZ36Z2xpr4gZMdM0AkYWMJrruUx7fApGxCy5dO0ltKIlkwYmGV8QvlGeX9deFl5pmqpq5+9+oN+RzIgEAKdXAQtWnOkFGzNi0H80GElPu3exnW2wg4xfu/Og4N9i3ZgRduATMCNE06za/9nCfE3TuDmbei1uDvQsMxKwmiaqZsQtcKITWEIQjCSSzn4kbhUhdJ1mFUzGrhcxvqcLOZm0hdtbbYUoTeMiYPVKpUQVsCocUyBat9vf+c/Z400k9N47XswLANBKmvaF1kQ6PWVvtkdBX0r4NA3f3dgtRQM4tU8qdz4Ad9MzyowAwPCg/n+gahqPYCRVYV0r7ruKotjZkSDMCD2Hfi+7JYIMRmYbxdKM1DZYn5cLO8JOuoVK0/D9e5IuwYjNmtsZjGg//k9on70chL7FzAaCNBebK7BV03iUl7pBoBlxn9S4STNqNU2M3RZjPsbbu/MCVr6CwqYZYY6d7j+dJLMMM8KniNhnw+1N1aiOYINm4mBGPM69a6M8lyCAZ1JMxspj3S7bJqxYlX5f5V62qFbIJQil4lWlvdOcSMm0CzPiVk0Ti9knfK9ghLenF6Vp3BrlzbDBSL/13TjHXMXj3j4jDGzNEvn9AKIHIzJNIwGgsKW9gJWmSSasm7NcOveygxTvVhkV/DkKwoyIAr/dL+tiX97HoJgIYqE9V8AGI1Hs4M3JQoFvmqZQPiNKUGbELlg0fX9M0WbO+p6NGTH+bkwMJJOxxJasHbemcsGIy/Mu0oy4CVg9TM8cjdEKImBlnimhFT23jJpzPrt+aRoq4GxqhUIn0hlWwMpMwI40DRuMMMfvFYzwQbEoTcPrhyhYZsQYkxXW2I1dPmAwAsB+jPx9wohYPZvk0e/UN+o/BAlcSoDy5GvmMzw1I3kIWONJvURwfNQSxpUaqhszEj0YsZoJGueIMiN8NY3qnabxvA7FwnwUsEbVjLAOrkFLe5WYUUIbUcDqtq/8PcXeq0mPNE08aWcZTGbEGOwzaestvqra8hXRNPuxurypKhUVIIC3ZsSLVXIt7XUJRnjTM08BK5eC4cEvo2p2m3R2/W7XkxX4VjJpGlPAak3qSjKlnys+TaPEQzAjnGZElKYx9UM8M8JpgwA7q2Zug0/T+Iz1NmaEu460vBfwraYBAOVfLgYWLITy6tN9v1sKSGZktuHCjBBVFav+RWAErIQVRlFVfrmU97q9/eUzGfPNBBMcPUvBDhZehmizyVLMQ82IYmNGIqRpYvEAaRom/w+EDmbNNIPi4oli3DuKSMCaSDrfhk3TM04zotqZEb3dPbXqZpkRPhhxGYY9S3uDdO11E7CKgwASRsAalhnRVCDLPbu8yRgHmw+LyYxMM2kaETOiX0ubQ3BQZoRps8EegyJM07j4jLBgOxOzy3s5sPJgKmp4hkthy3uDMCMdixA7/10Wy1RmkMHIbIM+xITYaWmb0tw7GLGJv0zDJitNUzbGZ2558UKW9lLhmlcwImRGVOf3io35pBnRWB1GBM0IYQIE32oaPhjJQ8BqNkMT+IwIBawJJzNC3/DjcXsgRver0mJGCBWwshOAqtoYDoUVKbJIiUp7uQDDqy9QVAErPSZ+crZ9VxX/zK+L3Rc3ZsTthcAYx5RalhmZFPuMJL3SNCGZETNNI2CWzMDUGlNINiseY9h7h92Gh8+IA+wx8t9lNSNlGmCEgQxGZhvsTWtrJMV8HkTt7NWAya2L7WyDoTn1N2iPt7jA64xQTSMUC0tmJC/YqmkiXFdRmsdNyMiXh4e9f0QpIZFmxFfA6lNNY+y/WeVhY0aYyYJtquclJjTt4FlmhLILIcpvHdsohGaEK9t1bJtjXdhqmnjANI2NGTECvMkJ694TVNM40jSRNCMeaRpRNY0oRUO/69CMJK19iCfcA1EKm2aEWxfrT1OmOpAwkJqRCCBTE0Cq0r+hnQi2ktMc8xAFZ0YAMMEIw4zwLoSlhkidz6ajosA4T+a5d9WMqLafiaaZdKutR8ZsMiNmyeB8CEYsAasSi+v5+kjVNCwz4pam4XQS+ZT2itI0PNvGMyO80RXb4kAUSFU6NSNKRRUI1byoasBghJYIOwWsZmfhQHbw3Dunm2Ouo7TXqwkfG+z7ByM2B1aeGXEbD2hVIMuMsMdZwQpBg1XTKCITNArefI8/H2DOO3u9ZwQpGsBuekYRjwPN7cCS5UB7p/u+0O1VVMI8YodmhE3TzH1mRAYjIUEmx6F9/t+ApasQ/8z14ZdXXd7Y+Rp8P1APAFPAygya5cKMhClDDAqutFdJJEHgw4wA+oRD30h4/4NZAplPaRqWbfBKFfgtb9OM+FTTmMxI2GCEmZS9BKxGYKskEuYEoIg0I+Ybftw6dvZZZjUjNKVQWamzGTnNXnnDp1BY0DRNOg1CiD4usJU8gHtgwR5j0N40DgGrR1rML01DuM/Y0l4jcPAKYkkup6dkAEPAyr35p1JWYzvAPU2jhGFGuOCIH78AJjBlxliRXoR+V9CVV0kkEPvyd4ON86wLK/eSqtTWWffpPGBGZJomLPp7dFpu14vRus9yb+wmzJ4rPupqCj5NY2voVSaOo44yxAgloDyyLpoRr2oawDVtQ2bTnXU+ObAKSnOjMCNKmEZ59JqHLQ1ny5BFmhE+TcOV9rKaEd3Zl9kfOiHmBMFIhknTVFQy50m13r79TK8AfXumxwmdIDlmxCtNE7G0V3G5rjZnZXafWPBsiShNo3hcdyrCV2JAVY2+L+yEy3eo5VnhKAJWt0Z5rOO1qLSXpmkcLEhS8JnxEhUkEAG4NA3vMzK/0jQyGAkLerPnctGqVmyaEcEEGTT14whG2B4aZcaM8GK7gtrBu1XTcAOcq1ZnFlMm84oZyVMzIhSw+lXTRGVGgqZpqICVeSFIcpoRvlydPofs5FTBVtOkrc9YR1N6HwfRjACWbsQ11VHIrr0+mhH+mQkoYCWOdJhHmsbUi9RZQRGbiqjgghGza28epmc8QydI0wiraWiapmWBfX1ssGouH9JwzKu011ZNM/fTNDIYCQs2BTIyGH552xu6oJombDBCyxJZZqRserG4COIKYQcf9xGwqlxA5hcEzgbmk4DVrKbJjxmxp04CVtNEZUZc7eD53jQcM8JqRnhtl5mmYe4v0/SMcWCtqGAcPoOlaZR43No2DWp4B2KvFJnbNnw1Iz5W845gxCeNQ3/nXyS87htWvEpR5RWM0HHA3ptGCSVg5ZgaEbMkELASmqZpbrWP33FRNU1IZUSFe5rGXk0jmZFDD+ykNjIUfnk/zUjQm1VU2lt2AlZeM1LAYMQ3TePBjGglYkZKJGAlmmoN0oVbqf6/4sI2+C7PVrhw9DgPPk0TkRlRFGfgQzSVWb/A9IzvTePS7M12fm2lvYwnhi1NE0DACgBJWiFn3N98J94gvWncTM/4oI52I/YLFkSBBg+H6ZmomsZDkMwwIybYVAQfjPBjnxszUhGitFeUphE1yqNpmspqoK6R2aeEnVUBwhc9sIyHI01TZ+1PdW249ZYhpIA1LJhBh4wMIWDmz4IbM6JyVLEf+HxrOQpY+aZeBUnT8G6ZAUp7+d9zJU7T5FNNFAHaf30RGBpA7LofW8Ze+cLWm8anKkK4U05mxDVN4xCwhmVGWAErN+FkmfvC1IzwpmeMLoTef7GYLqA036at9ZjOqew9WVFp3zafenKDwxWUE7AGMT1zaEZcXgoo+0LZA7cgk2cTg1TTqB7MiOAZJOM+zAivkfDsTROutJd4pWlEujwjTaNUVYHUNwLDA8Z3C8CMeAlY43Eo7/ogMDluWb3PYchgJCRsk14UZsTN/4IXZvqBL9djmZFyEbA6HB0jVF3wcDAjAezggfJK08x2ae+ul/VzPjYMtLQXZp3sW6Pbm3aQ5SOlacIyI4LAia4jx9w3QmYkYdeQsN1XAWvCpvdlLGbv2ktLcSsrQWzMCPN9L7iWFdu3TzTifDFybZTn8hya6aqUfd8c6ZwImhGmtFcxG+X5a0YUNhhhWQIuqDDt4B3VNCHs4Pl7Q5TmYvoUmRVONE1TWQ2wQYGHgDUoPEt7AcTOPC/U+soZMhgJCzaYiKIZUd2YkYiaEQqGGSHlkqZxWFcXM00zY/uao0ome2gKWPXuqXTiLWDglS8zYhOw0jfSIglYvXrT0PtCiVl22+yEkUzan8kpo9yUn7BZQSpNrYwMWt9vauOYEZdKFx4O91e+tNcjkBO92QPuzyENtFLcsfHXJcdtS/QMiZgRh/g2XJpGqaqySlkrOGYkwZmeRamm4feHDWgo2HWpOT2AnbGM7ZT6Bit4SCSgxOOwneWwaRov07N5BhmMhEXOnqbJZ/mCaEYoWAFruaRpCPdGG2XS4mGWQBvnyRhc2DbrAJwDpF8QOBvg37hmA8U6VnawN+n84jiwOoORsF17BQJWmrrhxavsdgDn2y195usarHUCHDNiTIxjI/r/y1YDh62wT+5BSnsBp0aBF3B7pWl4fQmFG0OZ5dI0QZkRL48T9nfeDt5LayQUsDL9fSp5AStNUdM0DXPNWdMzz9JeXsDqUU0D6NcikbQzI4yWSonHQQpZTSODEQkb8k3TiAIQ9vOgOf25kKZxa3eeBzNAeAbJGPjNHiDmtoNW05SGGTEp3qJvkznuojMjIc6lzTTNJ03DB7WEhDt/dL02sSzHFrFaLVvXXnve33wBoW/sfJomHrdYEwPKGy+w95Ni9RN+aRq+eoMPMLzYRr80DR88Zvg0jYuw2O93dtvmd3LOcx13v+5EFIzY0jS8gJWW9jqZERs7EapRnihNw9wnxjUktLS3qsoKikRuvqLf/VApgxEJN7CT2mi+mhHrISRhmRGFG8TiCcs5slzSNLxmpJBpmjiXpknb0zSOAZIVKmqlYkaY7RLNTv8WC8VKSdm8O/LUjMRD+ozoXw5+/gRpGqJpusbCdF91aV6WSOqBRDyh3yv0maeTpBlgWOke24TX3AblhFON7zKOpqHTNLyA1bvixWZMFkDASgix0jS04kTUGwfIWzMSrLRX93CyaUbY8lUHM+LVmyaYZsQMWryqadjgkV4LlhmhzwLvpUKRT5rGr/JqjkOW9oYFmwIZHbEsvoPCjTbnjZf8ILAZLjufEddqmgIEI9S6mzIjfJqGPwdqGWhGbEHQLOlGbCxQAYNUITMSzfRMCVjaa2uhHirwEQlYuTQNL1o1f+a8R0aH9VXRSZLe01lBmgaAcs6brf2mgZCqgvDPhhs4x0/iYEZ8PENE2xAtw77AUM0LrV7h7c4jVdNoAo+UIJqRgMyII03DBBJRG+UJgjlFUZzjrKEZUaqqraoWvnyZopA+I/MMMhgJC/ahJRowPhJyeR/Ts8iakTJ0YCUBB84wMAc0Y0BIumlG7AOmzQeiVNU07PWeLRFrscqYbdU0EXxGhK6oATUjQLTAx6YZoWkae18afjsKV2FjpWlcmJF4XLfprmsAGpqgvPaNzHqjCFg5zYibgNXhpsqcS/7tXKQzYavRKMtANRrZjF0UzwcfgRxYcx7MiGB5P9MznhnhU9QsKxu0msZhB88xuwYULkC0MSOdS/TttRpurIVM0/il9OY45neoVQzwE/3IENDYEnx51VvAGtgUx5GmKUMBK//2VxAHVv3YzPNEBay8ZsTLZ6RkzAgzQM+WiNVNo5QvRK6mUappgqRpeM0IEDHwYZry0XvTLKln0zRcNQ37Ga2gq+OCEXpulRiUZBKxa74PKPrbsgk26OKDCjdQHx01p6eVuGZz7l4gzP0VhBkxS5bj1rPFpkWmpyzRLh/AUwO5qUnkug8AiNuvLw2+eGYkLt53wnQ7ZoMRpbLa0n7wpmdx7kUsks8IX9orrkbSm3NOW+eY0Ywojc2Ife2HlqYo3zQNu7/zXDMyv0OtYoA31wohYiWE2G2E8zE946PkZPkJWAn/9hflDZoH/3bllqbx7E1TDszIbAUjAvatEGBLc6MIkzVGwBq2UR67/bD7yr+Ni5gRUZqG/m+kacxJ0jQftAcXSkMTlPom+37YqmkCOrA6mBHegdUtTeMVjNDgkfmMVtIw2hklFrc0C2yqhrt3aRCpfu9adH/oIpDRYeaa0TFJc6ai3cYDQy+CeNzOhjDBkeLqwJqjO6X/X5DeNHxKnB6TcTysAysApb0TCnVEdTAj4QIKJRa39lmmaSRs4AZ0EsZrxKvcNGpvGop4svzSNHw1TUFMz7jSXhefEWc1TTkwIyVI0xQr8CKCYCJy6oRzvuSRb5pGVEYcME3j0IyMjwJgNCOi0l432NI0ATUjjmoaahxGdRcupb1sKsXhM+LBjHCVQGYAwAYjbtU0fT36z0P9zmBEKGB10YwwKRpbxRRb2usWjGia3eI/lGbEHhwRvzSNquqBmBmMCPrDOAKZCAEFXa8UsErYkAcz4hR+sW+teTqwxuPlJ2AtRjWNo2tvwGqacmBGStETR2WZuGL4jCj5aUZErqhu342aphEFTnTCMQWsVjCiV8/E7Z+bfXGMdbkGIx4TBsvK0EZuoatp7MyI4jahm+XMitX11twPD80IP1nTAGB60vrMrWsvy97Q/aHBjZqz7j9HJRC3PpFeBOC69vKmZ5z/h6iaRol5j6+8kNrNNI7VjLDjDsviUOTpwArADLx875U5DhmMhAXNMTcYFGyYYMRR4ZGP6ZndFVCJxcqPGQnaBTQMeK8CRjNC2MHVIxgh7FvjrPqMsJqR2WJGilTGLAomompGzDRNyNLesPsaYyt3eM0Ilx6lAz+t0nDrmOpwYHUfUm2BQ0DNiEMsGbRrr1caSGRSl3ULRgQVNW7MCCuypQEG3X9Nc7a8cNOMuAUjrIaFb3jnGYzEzWPz9Kbh98eFvVLYlz56XuIJ5z0ECIKRCAEFDbxkMCLBwlSVG2ppEsZrhE8dFMoOng5MZd+1txi9aRhamT1u/hy49AQqKFvgB1uaZp4IWG29aSJW0/ilaUQC1ihpGoVpbEcrvURpGsBiBOj/fDBCBazGsZvVWl5pGltvmqBpGhfNSIILRvhSZ5FhF4VXmsYlGCEsM+LwGdFs+0hszIigr4+5735pmjr757auvRwzwl4f1S0Y4VJQPByaEb80Tc4uXhUFOo5gJHyjSuWkM4COxcDyNaGXnUuY34qYYsAYdJSWBSC7XgKGQ2hGPDvJCpwgvcBW0yT4YKRM0jSO3jQF8BnhS3vZwTOTYcRlXmmaEmlGSi1gLWhpr6iaJoxmRODA6ipgZYJaRdGXDZWmYVJKLr1pFO65i73/EyCDfVBoY0H2JUGJmUGKEjOMsoI4qrLbDlrayzfKy3GMip9luxczAlhOtrz7Kv1qVY1+fNPT1oeOahrNLs5nmYmEIBjhGuU5qqhETfJgMEudS4wKxmbub0bQoar6NWVs2cFV3rmCTxu5pmmYQgG2rFe4zvyZkdh5FwHnXRR6ubkGGYyEBZ3U2ow68lDMiJeANQ/NiMmMWJQo0VSLFi4VDOrXbFtfEAdW+3lSEgmrfDCbBmC8ybKDtqqWn2Zk1nxGisWMsNU0efqMuND1ju9SFoaQaGkakSeKyIEVgLLuVfYuuOxzWVtn6TBMO3jKjHhpRsKnadwb5fH9XVwErKL9iTFHZjjZErMvDS9gpWkaixkhIp8R9tqpOSvAYM+rEYyYzEJYzQiA2Bf/C8hmndU0gOGSq3owI37BCMfUBEnTcJU0wn0y1x9z6nckTMgzExY0t9rWof8/MW431PKCQzMiMj2LUNrLlx8CdvvzUiHLDfTFSNMAlmMk6zVCB206aJW4mobwb/PzxoE1Fu26CsptfatpojblYz1R4tyE46YZ4cFOKuwkSSf2MMyIGiZN49ebxqe0VxTssOkEeh590jR2zYhgHOOfL7p9rzSNm4aMlvYKghGlshoK9TvhwQYJIgGrXzDiYnrGBxBuaRrxOgUvjRJCyGAkLKjpVkOTdfMHLe91aEYKVNqb4JgR0bZKAb4jakFMzwRCX/o2x1Q6mVoQmlsuNTPCD7hhmsrlg2IFXkLvjojMiMJNAl7fjXIPCSt3OM1IqGCE0TLQ4CiQZmT2etMEErAC1nnMUBbTnxkR9qbhnyl6fwjTNN6lva4CVj+wAn4RM8KLXnm4MiPiahqSy4H4pWlsZeIyGPGCDEbCwuyNkrIcCacmwi1LwTbK49tr+0GUprG1ty6DYISnwPOspiGaygxyLDNirJ+1tKbntlIUjJRAM+LoYloCZqSQaRqmQiVS+o1lVoI2yrM15Qtx3WwOrLxmhAuY3ZBwY0a4ahqv4IKtGuIZDjfQv/PMSIJL07jZwXsJWAHrecq4pWloaa9PNQ3fCVsUQAZlRsZG9N2sd2FA3MBWHrHbpy8krE+JCHygyvskGRAxI4qorBdwVD1KuEOGamHB+hLQiW5q0v37LIKU9gYUsCpKzDJQpPoJ2sQply0PEStvtZ1vmoZNh7FvcJR+zTJpGhp8mH9jli2J34eLN0ORYXf5La4dvGswIYJosnK7Fuy2IgU+Hp4ogZkRplmaKBhh7OB916Gp3swFC18Bq0+jvKDMiE9pL/HyGSGakxlhtxVPAFrG8uTw8xmhOrwGu0jVF2w1IVM6rhx7InDu26CceLr38nxwlOPGLwOKTcDqpxlhg5HwlTSHEmQwEhZsKSCNhmem3b/PIojpWdC8Itfm3Po5YQQjZcCMmG+dPm6RQcEeE3vM1BI+m7FEhxwzQtwGy1lL07iUQxYbRRCwEkLy0ozYlg/TKE+JiQ27/CBy4/QRsPJQ4kkr+GeDEYULRrzeftlAyKvahYVfmsZNPOxZTcP8bDIj9Fm1ByNmNQ07xolYPv4+o9eJKd12VNgI0jQkl7U0I7ydvh/oOWGNKZW4rjN5+6UBlufShSwLzsImYPXRjEhmJDBkmiYsWMGb+dYw5bEAg0DMSB6aEbpfQJkKWOkbdMRghA4ysZjdjVAkYKXns1zSNHxapgQOrAXbJhsIRNGMsEEL43bq2yjPFrgwE1g2A+22X4LsfFG8vIiFoROqeY/6PHdB0zShS3t9hmCTGTH209GbxoUpovebUMDKbNMhYHXRjEx5MCMs0wMIqlnEmgtFdN+Mjhj7nXD6jPiBniu2T1WY6hXHvUFZcPu9wdrBe1rBA9xLo3z394IMRsKCeZNSKgVKc89lPZgR2nMiStdekUiqnASsCU4zkm+ahi/DFAhYzfNJq2nYNE1ZMCOlELAW6J6wBSOx8IwXO/mIAgR+c6z5lCAtQZ59HOTe/wftrzd776+gtJdESNMIg5EgdvCiNI0fE8q8rRNNYwzgfBxYXQy7bMsATJomRDWNgxkRVdM4Te2sY+LSNOy+mymaRm+3VBFoh2N2HAgVjFhMDSHEdbyByIHVJU2jsMG6rKbxhAxGwiLnZEZMqs4PQappIpX2ipiR0gcjhHe3jOLUycLNLdMUsHqU9roxBCXTjMxhAavGMRtu/VHcwAczQbv2ssEEu47eLv1/l5cCImRGuNJenzQN+4wpdSJmJIwDKyNg9U3TMBMfe354ZsStmkbEjMRseRr9PxfTM2Ewwt9HomoaY3+UWNw5CfMCVva4xoyuyGH1Iux6MxGDEZvDr+buQcO88JmsuJuAFbCusQxGPCGDkRAg7BsNqxkJyIyQIA6sfnQxhchnhP25nASsXJomsmZE0NQMgLC017xOVEmfdUvTHErMSKHSNCyzoYQXJvPMiOKTpvHqugsAAz36/246KVEfnNACVubvNs2IcezZIqVpaApLzdnv1TgX4LtV0/gJWI00DXH1GTEqUNLTFkPl0KdozvssQJpGqBkZocFISL0IwLyIRUzTsOdF1YKlaahbLO1VJIJZ7Sg1I16QwUgYsDqMRNKi5oKmabjJwFbpYApYIzAj5ZqmyXHBg5vyPyjc3mLpAMq+EXlqRoqgo/BDqQSsxWBGbMwG2+8lYJBJuGDEdGANYnrmZNdIf6/+g9vx2XxGuP4j1A4+79JeYz0BHFhJmDQNW65qC0Z4ZsSttNe5P4qotNespnFhRgBLH+Gwg1dt4w1hfUaEaRrOd8imGdGDESWseBWwxhmWIfWqbuLBd4UOkqYZH9V/djNiA6z7W2pGPBHp7Nxzzz244447MDIygqVLl+Lyyy/HqlWrfJf75z//ie9973t49atfjc9+9rNRNl1a5JjJLpEEqkOmafg3N5F2IYKAVSlzAWvB7ODd3mINASvJpJlqGhqM+DmwztJ5EllozwZcGgTmBTdmJGiA5UjzGMJm19JegYCVvYf8mBHPNI0L28YjsGYkGDNCAqdpmLdwUTBing8+TeNi2EWhxPRliF3AqvDVNImkPhlnM/pLV3WtuJqGd5P20ozwaRqhZiRCMBLPM03D7mcuY+2XI03DBCPUoI1N3bntl0zTeCI0M/LII4/g17/+Nd7+9rfjhhtuwNKlS3H99ddjdHTUc7m+vj785je/wdq1ayPvbMlBI2VaIlgZsprGs7Q3bDDCloyVKTPCv1nkaXrmalDlmaahwcihanrGGusVSjPCV9NQZ9GIAla/3jbCYMJIL2SzVrNK1zQNI2CNmqZJMBMKWznBv3l7MiP5VNPkgJzFdpjshksgSPxKh3mWkk7gIst03oVVVE3jKmCNO9mZBMeMsPeowYygMXwwYr6UMeNAqF4w7LWYmbF+5u4NczszU5Z3Sq0HM2JqRmSaxguhg5E777wT55xzDs466ywsXrwYV1xxBVKpFB544AHXZTRNww9+8AO8853vRHt7e147XFKYgqYEFEWxXPcKUtob0mdE1LUXYBTlZRCM5LjgoVCmZzxtKhKw0vNp2sGX2GeET9GVIk1TlNLeGBQ6sQVle3gBK+/9wYNvlMdua7DPWl8kZiSggJWmFmrr7WkOfrILYgevBjc9M0vYWc0IO6m5lvZ6VNMAzHnkTc8E54Gmo6emxOt2OLAyYlv2+lKYKSbBdadpmkgCVi5NE7YpHTumZphghNfx0TGWtgGJJ7wFrPR4g3ZkP0QRijfK5XLYvXs3LrjgAvOzWCyGdevWYfv27a7L3Xbbbaivr8fZZ5+NF1908QJgkM1mkWUmU0VRUGWYyoQu9/IAXVfgdTKOfIqigFBx18xUoHUoqqpr11Mp/U1EVa3laClqMhVsf9goPpG0jiWhmzMpak4PmMIeYyFhpmkqjH3RXWMVEm1/qABYYY4XAJRUhX5esxnmfOqDoVJZpf8tl3X8zfa9Yp8fLgBTiBp4m3ldQyZAUHK5whwncyxKLAbCMCOB1m8yFQpisRi0WBwEOnMjXJ5WZsTjIMaEoUA/H2Sw1/peVry8Qoh+38VjQDyh3w+apn83Z6USvfZdSRjLccGIYuy7CZa14NcRjxv3v6anaoz1em2XMCkBhU7aceZ5jxlOzESz7xddv9v+mOfRuGY0TZOqcH6fSUcrimLdU8mUzgxwAlZFU0HMEmQuTROPIxbnmAJ2341qGqWxOUJpL2VGrMqmMOtQFAVaLKbfG0wfnRjzgqgoChT6+4iRUqqtR8wr8DGO0/ValBFKOV+ECkbGxsagaRoaGxttnzc2NqKrq0u4zEsvvYSNGzfiW9/6VuDt3H777bjtttvM35cvX44bbrgBbW1tYXY3MDo6OgJ9LzM9jl4AsYoKdHZ2Ij06iD4A8UwanZ2dvsuPVVViFECsshpaJoNUPIYFxnIH1BwIgPaFC5FY4L+ukbp6GD6FqGloQJOxnoHaWkwDaKipQS2zT0GPsZA4qKrQALR2diLV2YmB6ipMA6ivq0NdgPPFY7KmGkMAKmrr0MYsP97aihEAVfE4Wuj51PTAr2XhQvRDHyDpNRpIJmH6SRKCzgXt1gBTJKRHB9DH/N5YX4+akOcgyjUcrqgA7ZyUisfQHuG881CrKkCf9s6FCzGzrxkDAFKJhHk/Z/bsxOgvvo+GS/4dqdVH2pdPJfTllRg6Ozsx2dyMIQDQNOEx9iYTyABoamnBaDKJHICW5mZUdHZi/OlpjJgrzgqfw75kAmkATU3NUBXo90pFCi2dnTioafo9unARUh7nZry5GSMAKlpabedwtKEeY8z3qmtr0eyyntE6/bvVlRXIJuJIA2hsbvG8D6a72jEAIBlT0NzUqI8/yaR5nKP1dJ1Vtu1O1NViGEBFdY3tWaE4YAQx7W1tSCzoxEE1p5+HRYsd56GvoVnf14oUajo7MVRRgUno46CWnkFVRQpV9XUweAJUJZOIVVdjHEBNbR0ylZWgiRMlYe17eswYPxUFnZ2dIJqGA0ZfmvbVhyPRusD1vIgwVN+ASQBViTimoE/+QcZlFvsN6/rmmmp93EilHOsYN5iS2NgINADJ5hZ0eGynu6ICOQCVtXVoLcDzNxsoxXxR1BF4enoaP/jBD/ChD30I9fUeAh8OF154Ic4//3zzdxql9ff3I1fAklVFUdDR0YGenh7d5IaBtu1ZYHIcsRNfa35GuvUhWIvF0d3dDTKp05bqxDi6u7t9t6caZWua8baTmZ42l6Nplb6hISiaf1SqTlmpocmZNGaM9ahGXnl0cADj3d2ex1hsaEY+dWB0FEp3N9S0PiSNjY5gIsD5cqxvQJ/O05pmO9/ajL7e6bER63wab7xDk3rYQTIZ82/qpL2xYfeBA1D82ovnCdLXa/t9ZHAIYwHPQT7XUB2ztFzp6alA96kfzLy+EkNPTw80Qy+WSaetc3zXn0CeegTp6jrE//Vj9uWH+vUfYgq6u7uhjRnTuaYJjzFn5O+HR0ehGezA4EC/fk/tepn5Yg5dXV2Ot7qcUQUyPDYGTOjXfnpqUt82vUeHR6BUuJ8bLaWzA5nWDvu9N2HvSzU1k0ba5RxrxjM7NTEBzUjtjoyPe94H9NxkZ6Yx0KsLdTUlZu6DZoxBU5MTtu1qw/pbezqbFV5zYki9+3p7oWgKNOMcDYzozyoL1XizH+nuwlh3N9Rx/TVIM1JX05OTmOnvt87BxLiZ1pqcmbGlJEk8bj2jw/p9pGb1Z5OMjegMi6Kgbzrj2A8/qIbuZdq4Pwli4e93494ZNMZ6Ek/Y1qEoCmqM8VszAqdcZbXndnJGKmzG5VqUE4oxXyQSiUBEQqhgpL5ep6NGRkZsn4+MjDjYEgDo7e1Ff38/brjhBvMzeoDvete78N3vflcYgSWTSSRdSu2KMaESQmzrJYRA+9F/6gKlI44xG2MRRkBJCAGh/QhmpqBpmj+1ZeoYLCMuQoguNqOOkLFEMCEg5zNi7r/Z3jrrOKbZDkbo8ZJEUj8m4/wQVY20L4Sx4rctn7RyxeZxGkErYc61pqo6rc3pREgu568ZyBN8pQgxrn2odUS5hlxpbyHuAUscqejrY0SU5vqNZ4WMDDm2SRjNASGEqabJiY9RoBkhqgoQAtLfY193Ngskk9A23Any+IOIffIaSxehKCB0ebqv/D3qhqNPQOzaG4H2Tvtz5RCwxtzPMdtQkNFUeF4TmuLIqZZPUTxuLkODCtu5h3WOidv+xOh50M8jTdOQVMp5HphmeYQQu9cS3ZZb116FT9MkrH1nhMuEEBAm7cEeY2AY7CahYlyva+G6DqP8mgpY+bEGcLpk19Z7b8dMSyUK8vzNBkoxX4QKRhKJBFasWIEtW7bgpJNOAqCLU7ds2YL169c7vr9w4UL893//t+2z3//+95iZmcGll16K1tbWPHa9iMhkLOX41IRVyscr76mwS9P0h5lOfG6ggwl9CzebXzETVZRqmjJ0YNXtlHkBa5FMz8zSXuPvrCCOvSaqqk8IDrfKWRCxlsyBtQhlzMzkrv8vKNGkzwplUViw1S2Af5WV0PTMWEe/nXFCTg9GyD/vB/a/Aux80dovdmKkATHfzNEFiqIAiw5z/oHXCnj5WrCCT1P/EdQO3k3A6iIKp1ooN4EsI2AlbCluUsAQUm2cWU3DNZBzVNPwvWlcmnry1z2fsl6A0YxYwUho0POVNhK5opdifvzx8hhh1ymraTwROk1z/vnn44c//CFWrFiBVatW4e6770Y6ncaZZ54JALjxxhvR3NyM97znPUilUjjsMPsDXFOj39j852UFtl02W6HBK+8rKq16/ekp/2CELzflu0MCwRXXfnbwpXZgtR0TLe0tlukZV9rLbptW0wDmROVZYl0slIMDa8FMz5jJHbCuKxtM0G3Rt10W7EQFBHBgpSyCYgt8CCGWx4i5XeMeofdKLuteTaNGeO548GyoV6kuWzVkBhYhSnvptWT31S3A9zA9Mxa0lmPHOK9qGiO1ZDJjdD8cdvCq3RvGrVkcV9prpv8iByN5VtOwy9CSXQFjqjiCER8JAj1maXrmidBn59RTT8XY2BhuvfVWjIyMYNmyZfjiF79opmkGBgbKXjHsC7ZU1+bqSZkRo+ukouito6cmDeMzn3I0OkDz3hdsSWLQ6LncHVhZzw9HaW+epmcOnxHOgZUdGCuZAJEuzwcfs8KMCCy0ZwGkGGXMrKMpIJ4QaTAwNgKiqfY3dMIt7+fAStfLNsrTNL3VPHUFpS8FWfszRbIZzoGVYXHY5y5qmi5Maa/CHGdY07OcDzPiYPsYnw/hfjMvBvRZVRRxUGZ27uVKe2ngomnO1hZs+a+bJ1LMqqYBYAaukdxXAWfX3ijzkMmMWGkaHs40jR8zYlx3aXrmiUhnZ/369cK0DABce+21nst+9KMfjbLJ2QXLjDCTKhGlCSqr9WAkiNcItYympag8MxKPBzfp8W2UV2pmhHOrBQpnesabEPE+IzanyoT+T80xE9UhxIwUxYGVCQ7Y/9nrSrdFNGBsFGhkAnWeGYnaKI+yIo0t+jObnnEyI9ksZ03O7Cubyow6UTiCkSBde7UQaRrGgdUcJ5hlojIj5nKwnhs3WwGqGZnhghH63LG+KYA9TcNrRkTMCP2uIQiNYnhmW3c+aRoaGKfpOfFP0yh+zIh0YA2ECFfrEICNGfFI0wDhmuXxzAgdsMMangH23LSIGXEzgJot0GCI9QTxc9r0XadfmoYLRmIxPbhjqW6gNMxIyRxYi9ibhl5PgWbEZrrH60ZclvdvlBe3ax2oeLVtgTVB0OOlE1I2Y2lc2Ld0VbXup0QinFMni1CmZ4IUUcBGeVCz1n0rMj0TNa/z2h/WgNB0XxWzQ0o1rxnhghG/3jRxl7GK23diakYiGJ4BTJqmkJoRUZomLDMiu/YGgQxGRLBpRgTN19jImAYjQfrTOIIRKmANaQUPOKppHD/PlrOoG0xhIPMwFypNw5+nJJem4d8gTR0NTdPMPjPi6LsyH7r20usp1IwwwQivG+EnSpMxCNAoj02zGMGI0trhFG5TZo5lRpSYFXQQzdnIMQoi2cGHSNOYzzOjy2CDEVodxOuw/OzgWUaFBvFu5e38C5exbpORFHbttdI0iuhlid0H+l3TfTUiMxLn0zR5aEboOoKkaXyZEerAKoMRL8hgRAC21wxh21EbE6ytw2eI/jRm/t5NwBpmUPRN05SYGeGt4IHCVdP4CVhNoR8XjGRLqBmZj117Yx6aEWa75hsvBUvhA/5pGlujPCbwoXbcLW02RlCvkgkgYM1GeO54RLGDt6Vp/DQjTPWPV5qG79orYlFYiJgRUSUNwFTT0DQNraZhAiW3app4nEvTMOeabwNgCljzZEYKUk1DBawFqKbhHWclhJDBiAiuzIizqVao/jSO0l4uTRORGRG+eZScGRE0IBN16QwB4tebJpuxeYw43kjoOXGkTGaBpSiRgLU4pb0uwQR7TFkPZsQMLuzBjH+ahtOMmP1UKuzsl5qzAqNsxs7ksPuac7mfwiBKmoZlDvwmKHZMMN/WBamOsMxITFBN43YezGoaY1w0y4BZZsTDZ8QvTUM9Lcw0TaN4P/zgSNNEmPypz4gRjCiiNI0tGFSAmlrvdco0TSDIYESEqYClvUC4NI3JjHA+I6I3Hj/4MCMlb5QnOldhW83zcAvaKpg3umyGobONwaksmZFSpGkKXdrLdY4V+YwATs2II5iJmKYx3/4Tdq0Ue+9neWaE1YzQNE0ek0SoNA1TPWLqmgJW0wBW8zZ+MgTcq2ncNCkso0LPQ4VfmmbaHuzbNCNcCbnonAPiQArQq6JoEFHXKN4PH5jpE5ZJC70SrrRXlKZh2ZKaOncvF/p9Kt5ujMj4HCKQoZoILMuR9WZG+Bp8T9DlU0aahmiGG2MEuti1a+/sCVjJ+BhQWydW4IvSNG4dRoPCLU3D0suZtJOi5s9JKXxGHAHQbFXTMPeB4fbrN3j6QgtQTZPzSNPw1TjGhElUFcJiTJEDK1tOGk/Yq8jYY7aV9nLBTEGYEW6PgzIjfqW3FGzgQSs8bJoRn2oaP9MzooH4MSM0TUM0ozGeoJrG0/TMRzMC2MdPt6DID3xQGamaJmSaxi9FA0C54BIo614FrD0u/P4cQpDMiAh+aRrWrTGfahrAvWTPD2552FkSsJJnHoP26UtA7vuz+AtezEiepmc8darE49YgkslYyn5eM8JX08RnMaXFv/VHPQdhwQc9hdCNuFbTMBNiEAErXS6edC5j+z7rWcFQ+6bWKmFNGrms8wXC5lMiKO0tpIDVK+3C2sEHTdOwf6eddYWpjrACVkGaxk3AmkpZ+zE9FShNQ9hrxhyDbd/ZYzOZiET0YJm/jvkIWL1Mz9hj8BOvQk/lK0e/Sh+nJFwhgxEBiGtpL6V1RWmaafiCWjSzkb+aY2jPiAJWtsX1LAlYyc4X9R/27BB/gbeCB2xlmZEgYqboqinblM04gw2+tTgdOHlbfg7afbdD/eZVgcTJviiFTgVwBloFCUb4ahoRM+JV2svR6Emup4jb9myaEZZRtJgR4pemYcvL3Uz0woCfOD3t4AVpGp8JSlEUZ5WIoJrGmaYJ6jNimZ6J9BHmPlAn45lpp4DV4cDKp2lcWFw+TQO4B0RBwL/MFYIZ8UvT1PoHIxLBIIMREWxpGiYYEQ1eZjWNvXunEOYkWGn/LIrPiGtp7yy97RuVDGRyXPhn4ilgzTdNIxggaICXTbuW9hIzTcM5SLqcK/Lw34HdLwO7Xoq2vyzKQcAq+j0KHA6sPpqRsWHrTVm0vKlzcglGbBMbE9CyEzrbBoFdj03Ayryla6p1P+TBjCh8miYAMxIqTcOuM+2hGXFN07gM8ex5NJkRj3QVdTLOzDA+I2zZMV/ay55zQbUf/RsF1dy5VfQEQSHSNA5mRJSmYV7+/DxGJAJDBiMiuKVpss5gJK9qGgBQc8ygWDgBa9GZEVpWOeUShIny8cUyPQOg0NRXJuN860xyaYCAzIj5fSoczAflIGAFUJA2Aa4OrGyahgnwNA2YGLP/zi7HaA+EFTXCahpWM5K0V9Mw9z6xlfZy1TQewW1gCLr2uoIp0zUDpCDUPX2+Tc2IyFKdL+31CXbY1JppeuYRCJjMCBuMGN/XNGsMA4xqJmb7rnbwzLmiJmNeAZEf+KAyn9LeTOHSNBLBIIMREVwErMI3qTBpGjboMHtOqHa6OSAUtwd8tgSsw0Yw4sKMmNRvQpCmiaqX8EzTUOMzhhmh54Lp70EIsSYnYxnilrowrgtJp8V/D4OSde3l7oNCMCN8ozyvrr0UrG6E15yw11N03woErKxOQUkkrEoKXjNiE7DGxWmaRD4C1gimZ2F7UcVpGosyI4wGw2Q4XIJdP4dXtjeNFytBg/30NCNgZdM0LtU0ca60l2UVGN8YUog0TUGYEUZ7BohZMzZ4DSBglQgGGYyIwDAjRFTaK6ymCZGmSSTsrcGLUNpbzDQNIcSaXCYnxF8SCliLmKahg1g2Y7mdGudTYd+a2UHTjxmhx5CeR8xIITQjZjUNrxkRCFhpTp3VjfDMSNBghBOw2oJO9hrn3ASsit14zBREz7LpGXuMgdI0vGYkQJrGz+GVPY9B0jRGMELSImaEr6bh0jRuL07sfswYz1jJgxFuGdFYw96vUjNSMMhghAMhxL9rr7A3TRBmhKGVbQ2wjEFxrjiwTk1YgcH0pF0PQCEKHGIFYkaEaRrGEp6vpkn6BSPezEhB0jS8ZiREbxpt453o//LHTSOmcNvly5iLUU1Dr6vRCp4NFFra9c9szAgfjDD3r+i+Jd7MCOJx6xpnPQSsrAGXptqZyqgIk6ahf2OZm0DMCK8ZEfSm4YIREqK012Ye5wbKjMxMW0J8UzPCV9OwAta4e2kvwPh6FIIZKUA1DX89fHrTKJIZKRhkMMIjk7FPWFknM6II0zRT7g6SFEJmRHWmFYLAVk0jELAWM01DUzQUIt2IKKVSKM2IR5qGZFmfEWeaxjZoBtWMFCJNk4cdvLbhDsxsfhRk98vht1uU0l63ahpjQmTOsdK6QP+B9RrhBKyKonjft24OrDbNCCPc5n1G/Lr2FtCB1ass1eyLk82TGRH2d3ERSPvawcPfgRWsJot5vmymZ3zVljFW8o3y3NgLmqbJ51oUgxkRvSDaNCMyGCkUZDDCg0+3ZLj8MyCsptHpTp83VzboYD0uojTKczU9mwWfkREuGBGlakQDfcyFUg4A/W3bvRTT0oxknGkvN2aENW0Sga6nkGkadgAPCsrUhdwPQkjgyqFQcFTTcJoRNhho1ZkRm2ZE1FGWrYZhQAixCWZtje4Epb3IZu1VOTZmRNF1I3QfCuEzkneaJsAQ7CVg9Svt9RWwMqZnXqxEJVPa69CMaM5niO2c6+aJBFjBUkFKewshYOWCS9FYE4sBNXX6dxtbwm9DQgjpwMqDr4rJCEp72QeKGgKpqp6qocGJCOwkKWJG+IfJC65pGs5TowggDmZEFIzk3yiP9HaB3Pv/oKx/G9DUZv1BxIxUMm9uxrkxTYb4viXGviiJJAggnKCJxuS9C5Kmoc37krquJUwwQsseMyEZGltKqtJeaZQP+DQNz4ywAQVN07CaEX55wLhG005mhE3psY3yiFtpL5+mydhTBsLeNPlU0/AOrAEErPTZiMfF7sU8TEO/4GkaXwErex7NNI0HK0GDhPQM4zPCaka465ZjghF2f13TNEYvmIJW04Q3GVNicdjOpAtTE//Y1SDTk1BkNU3BIJkRHjwzYnNzdNq2K4oSSMRKNKacz03AWgDTM5YZIVGFon7gHTVFFTXC0t5wvWnIpntBHroPZNN99usgyuOypmdu1TTZnH2QZgNCx/4zE2oh0zTs22QAEFW13jLDMjRs4EFp9kKmaeg9yFqLswxWLAalqVX/mQlgiYgZMTUfnNeIxgcjbDDhImB1c2BVFLtmxDQxnG1mJGBfGgq6f0JmxCVNE1TAyvqMeFbTGMxIeoZxYHXp2gtYASEfjLixF+VSTcOntVzuDWX1kVDWvTr8+iVcIZkRHpQZUWJ2cRfg3hulqhqYHAfZtxvazT8xgxLl+FMQO/9i/TvshGdL0zBvFVGqaeJxi7qm6waMN0c12gPph+EB269kcsLZU0Q00Ic1PaPeFFMT9goJQTrLlqZJGXvDp2lUJk3DNlcTsQXsm14h0jRUsJpgBvAgYEvGQzMjIfQxYcBO7oD9HiPEnv5oNhitwT7mO6I0De28zL1h88EIK4IWaUaiOLAWMhjxKqUNUwZsWydlRjwcWHlRuPG7qwU5u5wR7CqeaRojmGX1Yew4yDMj9Pnnq2lcAoaClPZS5kzEvAVeBy9gzePekAgFGYxwIPRhq2/URXeiNE2SO23UhfXmH9vSPOTAHpDz3q4PCOybgy1Nk0UkzYgZjHDL8GWSRXiYCM+MCNM0Ago8pIDVdLWdntJZDQBIJIXUts2BlU4IfG8aVsDK9rPxYUZI2CBABF4zErSiiA1GQjMjgsqhgpb2cj4jAMdYJIH2Tv3niTGQqQko1bVOzQlgWcLnsvbAlr1XWJ8QNk1j04zwDqxpTsDKaEYK0SiPn/A87eD5wCVoMMIFzcLeNCFLe8OmaWhpL8v+ss82b+VPn/+4h+kZu3+mA2v0a6ELoZPW8RRLwCpRFMg0DQ/6sDU06v+LHFh5k6Qqg8KcngKqaxH76Bf1m1rTgLER/W+2YCRuf0OOwowo3IRLwT48xRKxUsqdircEaRrilaYJOhEbgSGZmXJnpQzEWGbErWtvlmNGvBrlFZwZEVhoB8EME9xGZUZiMWa7hUjTGPvuxowwpdVKZRXQ0KT/3tdtfYdfjk2zsHBjRlxKe4nKMSPsc8d37S2GgNXTDp77W9hghCJMNU0AAWuQahozzceK1dm0Tpa7N7MBNSOFTNNw61ciBSP+pb0SxYEMRnhQZqPeGEDVnGWi5SZ4oy22AcT+9WNQjnsN0NCsf0ArT1Qmjx5j38pzTo1DENCHRmQiRCeJPEWsRFWh3f4bkG3P2v9Aj2nxUv3/SYFWxtNnJGCahl6L6SkrTePC9NhLD8W9aWwC1hDMSEGraei+BC3ttTEjEQWsTOBFClJNw6Vp2MlGzdpYLAAmO0J6u4zlOQdX9ru+AlY/zUjOuQ52ecqaqUxvmlkzPYuYpuHHBWGaxoUZcUsbsc9iADt48/kKyozQc6vEbKkixTcYyXPyd7ObD7w8t4xM08waZDDCg+o9KDMCANm0XZjHvUkpLXpeXHntG6G86lT9w0YjGKEsgkNUyUyEKjd4BwFVcdc32j42qUogf6+RF54CufuP0G69yfyIZLOmlkNZSIMRgYBV1Ak0rAMrHfhmpp0THAfWgdVR2ks9SDKcBwkbEPJgz11B0jSc6C9oNY1bB+kgEJWSF0TAyjEb7DXOZBzPidK+UP+dMiOiJm5smoWFgxkxlrExjUxvmiwnYGURi1mlvQDj21HA3jReaRqeCQnMjPDLidI0PDMSrLSXaMRiNTzTNAb7y2pG/Jxz6f7Z0jQuAtZ0ARxY+X0qBDMi0zSzBqkZ4cEzI4A+wCaS1iDMRcvKW94D5fBjgGNPsj5sagFe0RvKKYCzfJe+qeZyDF0cojdN6wLEPnmtWTppQyJhn5QjguzZof8w0AdCiB7oUFYkkQQWGG+8XpoRweAQuKzVphnxTtNQzQjJZKDwpmdmX40Ze+qCFRHzKHAwQtSIzEi6AALWeNw78AoLrjeNoij6RJbJGL2BuPuZ6kb6DGaEF8BC93MggHuaRlGgKAqIyfpxLqY2O3iXiVFR7BPUzm36x3T/oiBUmiaaZsQsQae/i5gRt2qaQALWINU0nICVvae84Jum4XxG8unay68/SNk0D4cdvEzTzBYO+WBEZf0PAGsCrK7RBzhaKphjbkqeGamtBygjQj9rbNEHEDNN486MkCgCVgDK0SeI/1AgZoTs3aX/kJ429DA1VllvYzOUmjr9GEWmZyIK3I1SFm2bEGvgmwmQpjFLe52N8pSKSn0/0zNWVYsvM1KkNI1pehZUxMsyIxEFrGzlUAGYESIIJpCs0IMRW2m1wYwsWAgCgJjMiJfpmUswwotl2e8lElCSCSuY8WJG2HsvkwE6FgErj/A6XG+EsYN3fLeQzAjvM+KnGTGuHVuW68WM0GoaGhzHDI8UWnVIQcdMdv+CaEaCGK8FQSLPNI2spikZDtk0DSEE6p9+hZ4Pv9PKZYMZ/KtqrAcjk7HTx0GoOyruHDYmbz51wIono5ieeSGkCyuZmnSwG4QQYO9O6wOjnJeMMOLV6lr9Z2GaRiD2NfP9AdI0mbQ1oE5P+4oNrWqajJ0RAMTMSDxunW9fZqSUAlaxZoQM9bt3Gza3aR2r4sUChYUomLB1TeYCUTNNwzEjwjSNi88Ib7BmY0YS1rXMcQ6sLPgyUwDKa88NZjzmhjA6ED6oCDpZeglYWRM3FqJUGAt6zGygTQN6Efi/0WPhNBYx6tTK7l+QRnl0twqapglveiaraUqHQzYYQSYDsvUZaKPDUL97DciYwZCYwUi19aaQSTOuiYlgKu0mXTNiTt48dS3UjBSIqArhwkpyWWjXfBTatZ+wypoBXesyPmr9PjRgfQ5AaWrRLZEBs7SXvPAUtAfuNrYtSKuEqaZh94VoIDTgcWVGqENk2nk+bcFIUM0I81km4993yA/G5GD2NQqaqrJV0+gTBzm4F9rnPgDyi+95Lyv0VCmAMy/fmwawrnMmYwVJcS5NMzEOMjlhTpwKyxQk3ZgROqlS63kuTUNdTNl73u2+ZzUngM6onHK2x4EGQD4C1qDVc/z3gviMBC3tZQNtLxagkgtG6Hr54K6C/15AZoSikALWfBvlKUq4CkeJvHDIBiNKRQXin7wG8Y5FQH8PtO9/XS8hpQLWqhprgM0K3vb81k+ZETNNw7W1z7drrxfCpGlGh/XUy/AAyN//Yn2+b6fta4QanZnMSDNQQ5mRCRBNg/bT/wa5+ccg/T0udvAhqmn45ns0MHLVjDAOrG6akQzPjATUjAD560ZMAWu4NI3I9Iwc3Kv/37XPe9mcSDNSCGZEkKYRMSM0TVNRaVWX9XW7mJ4xAlQWZuBj7D+dYEwfC97YLuedpmG2qZxwav523qHs4CMKWB3VNEHSNH528FQ4aolXPV+yKjjGw2RGuGBEFLR4mp5x56Cc0jRJsaeRRHFwyAYjAKA0NKHtaz8AauuBvTtB/noLx4ywaZqQngR8msZVMxKxtNcLXOWEpy08dTkFQP7+V5OBMPUiFGYwQjUjLVYwkssC3futczc8ILTOtxlO+YG31h8bda6PgfL/2zvz+DiqK9//bnWrJbVkWbYlWZIXecfEeAFizGZsMGGLk0ASG2LI5AE2mQHymGGY8CYkLAESCAkwGcIkAbM4QzCEF7aQkAlgEggEeNgJ2CyGeMGbbMmSrH3rvu+Pqlt169bai7pb8vl+Pvqou7q66t6qrrqnzvmdcyXvh5myqRojve6eEdd0VzUEEhCq4QcPIPnwf5qGggOHgDWsiNclTCMMlKDwkZzibIYxsplNI924i33CNIAldj6w16PomVEnJEgzYnhIzFCMo7Cdt4CVCQGrcd7ZKWf6dDIkGaX2hg3T+Bgx6ZaDN8M0IYWjxcrnkTQ9I0GT2WUqGM04m8bFQCZywmFtjABA0YTJ0L52JQCA/+VlS/9g04w4n/YCGWMYI309ug5FdV3LpciFAFSqV5IR4sbe04XBb/8T9px/GhL/dRuSb73iXLfDMkbQ0w3++yf17wpjRKQoG2Ea3rwfAMDGVulPS2JA/2iLtZ32tszDNKox0tFm65tKdLyhS2hpsowiVTMi6wkCvAWOQTGgxgd//SXwV/+A5FOPuK+Q5tw0ruXgRegmqO7IEAlY/cI0vN8pIAak9N79e/09I2r7vASsqmfEltrrYoyIyRMZA1txKdjnLgBmHeXbzVDkIJvGGaZxyRhxpPYKobbHPlJMqWVaxH4tizaomo+MwzSF5BmhTJpcctgbIwDA5i7UvSMdh6zwQGncusEO9KcepikusYyLtoO2qpQA7AJW4Z3I1gyQYh/btwKNu8G7OsDf/jP4z+8A377VtioX+zbcsPyl34C3NJviVbZgkb68tVn3sOzdpa9fP1l/0hQi1q2WMcIPtbkfrxSKnnElTMONMA3zqsA6ZhwwarS+7V3bjeNg7Fu+QQojxxamCeEZCcqoEe19/6/uAkpTwBqzvw+AS5oRsw0pe0ayndobLkzD5KdgWcSqlpMHfIqeKeuK39CgpeGyf98jTCPpB7Rly6F9flV2XPDqgOdbDt4nK8aPMGEaVRQeWGfE6HtvCvU95OvIPB92caoj1KyKhr3KwQsy1Yxk6hmJkGckX5AxAr0qIFu42L4wLgtY+9Ob4VMufOZV9Ky/35rbpTxbxojhGdm9AwBQNH22mb7It2yyrysKmM09Fpg6C+jrRfJH1+neDaaBzVto9KFZ9zr09eg3FDG4GKEam2ekpcl6nW7RM4dnpN3WNxXGGNjEKfob4d0yy8EXWTcms05C1Ncz4hgUg4wR8XlfL/Dhu87PxZNqJhVYhWdEhG76ev1DcGEnBUwVlwqqppFoM9xlz4gI0+yzBkq3CqxeE+V5eUZEv2QBrDxjrGAoJoyU2xNmP1kL07iIND0FrP7ZNFyEacIYAbIxYmYFStuPRNw1IfnyjGQ6UR6l9eYUMkYM2PFLpTea7ikwq3rKcfAULHcjVMPbDjozDMR/MXeN7GXIFHFjNzwExZ+aD83oH//gHfu6kldGu+zf9HlERD2I+kmACH+0HgR2G3qI2glWWWeRUSNPnmczRlyeVEJpRrrt7wPCNAAAYYwYiDYyxlyLNjG/AVpdFiRg7bWMFf7OWy7bSzdMY6/Ayjm34vxySXQXuKtYN4thGs3DM+KmrxovCp/tc03tZZ7ZNAGpvaqnUa4zIoc9h8oYyUmYRvnNuxY98xKw+ldgTanyqZy266YZiUYtYb5ATe0dYmPE5o3LWDNCYZpcQsaIYOosKwWxtFR/0jbTFaUbbArWsplR03rQWfJdaC1E0bV4ufd036kibgiGoRGd2AA2e56+7O8f2MMIwhgpr9Cruv7vG8ybDps83RLi9vWC/92oWFk/2fq+iwHF5enipZsTC9CMJDc8h+RrL+pv1Gyadv9sGgCWZ8Rl35YxYnihgjJM1Cf0AM8Ilyql8r+95fRYOOamSaPOCKB70sKWiB/icvC21FzZi+g2vUG1YdR2dVi/OTlMErromTLvkppNw7l1ruKSMTJUWREpeDtMAa25brpFz6T3XuXgRXE/j32Y12IqxojNM+JijESi7nPP5FTAmt1sGiJ3kDFiwBgDW7RUfyOeqKRsGp6qgBWwBvK2Fu+iZ4cMj0K2QjSQnjINiiZOAWon6l6PwQHg7x+Yn3HJGAEANnkatG9cDxx1LNiyz+n1O4zP+Lsb9XUnNFj7KnPx5gjPSFHMHpf3KXrGO9vBf/kz8HX36MaSGqYJcfx9jRGjaJPQojDbrL0uhoHiQeBhwzSA3n81qybd1F7VQ9TfB24rhObTLls2TTaLnrloPlzF3pIhWiz9jg42Ob/vWfRMCTcwxTOiakYAy5uUC89IKqm96ufZSO11yabhnFvGSZCANZXZcm2aEWGMqGEaF2MjbGpvLJa5jidjzQgZI/mCjBEJdvLpQOU4sHmf1hfIcfA0PCO2wmeGMcJUzYjwjJSPyqTpdpQLPjpxim5sHaF7R2yhmk5DXyEZQ2zWHESuugGsYbq+YGyV/n+3HvZhEyTPSJnUbrFf0Sf1WPl5RoQmJJHQPUmytkPG7/jXT7bHieUbS4mfZ8TFW6B6RoLCNOYTpiF6/tub9s8d2TQhjYI+1TPSq4Ru/IwRyVU/5Nk0AWEaQEp3N9LE3Z5CvWbtNQWTHmEaeV9iYC6NW8tyFaYJ2A+TNBYstGdErcDqVvRMMvBtkwsGFT3Tf9ehKp+6eUYUPYjTMxKxDJ1o1P94ZTovjdiH27bDYjOcKEyTS8gYkWBjq6H94AFoq/5RX2B72ktdwOoapjEvYuOiEcW8sugZsbWxuBQRY1ZhzJ4LAOCywFIIWP32P6bK/t4rTDP9SPt6qsvVL5tGLkff2myV5Rcp0l7blGBFMX2uEYF8HGKKZkQLKHqmGighPSNsnj5ZIt/8trI9JUwTwkPBEwlranZ5Dg+PEvEOjH0wScDKs1KB1S2bRjLcvSoKm2niTc7vB83aq4ZpFO8Li0ScgkXZM5KOmDEMTBnsc+IZcXn6lw182dD1LHomsmnCC1iZa5hGNv6jTsNJ08BGVYCdexHYVy5zej7cvGuZkLGAVTaOyDOSS8gYUbBdLEVyNo3h2UhDwIq2Fu+iZyL+nlVjRLog6yaYfTJ1I9u3Wq5+F8+ICpONkVgMqBpvvZfCNOb2zXaonhGfomeSMcJbmq0wzdhq/22qbZVDNb6ekaBy8Glm04jaFQeb7J+LEuiphGkko0OrqLT2k3KYJkAfkyou2TS2omcenhEmjBFhgLvc+D2Lnol9eYVpAFv2DgCweB4ErEH7SccY8dWMuMzaK59jT89IGgJWuQqrWWckhGYEgPbZldBOOcvZDNuUAFnwRGRxbpqsVcQmQkHGiB/m014f0GMMYmpRHz+EZ6S91broxVONetFm0xiRnpxY7URredV4YFyNfrP6+H09tqxoRlwZKxkjdZPt7mXZGJk6y35TU58sfDwjvMvuGREeDKYaI0FPK5KexXaMVc9IYDl4NZvGo8S4wAinsNFjbO9N0hGwinBMUQyaOM79fSmEaWQBazYrsHqHaXh/v7e+RxgjgnQErGadEUWD5ba/XAhY/Z703VaXPRWhwzRqNo37078pmk6GMUaM/6nMlitXYRX9jNiNkaCJ8BzI38+GZ8StBksK2JIIqOhZTiFjxA+5HLwo666GDfwYNVq/2Di3XNNqKqK5bhaNEbm+g2SMMMbAjCd3vu0D/QlbDFh+mhXJM2LLpAHAZM3IhMmAeIIHnDFXP82IEqaxPCNKiCglz4gsoDSMEbM6a4qekaACYyK1VxgjvT32jBqX1F7fGiHGNgAAJaVgIq2yL5UwjSxgzbzoGe9oB9/5sfusu1JIk7tl0wCWcS4IU/TMq86I+T0PY4Rp7kW6so28XaYFCzA1qb0hPSOOLDu3bBrAuq4SSffPbRtNI6VW9oy4CVijUYd4PjBUIn9fLTmfDhlrRihMky9ClgA8TJFLXIsnCFU/4QPTNP0GfPAA+GYjE0UN0wiGSjNSN9H+Wd0k/f+BfZZXpLjEV8DGxlTBHDZlzwNgtTterk+GVlEJGCXjnQJW72waR5im2yNME/S04hWmEQOTnGUQxjNSUqoP/j7hED44aA2iwhhJJvVlZlhGqcAq2qJqDmSE4VQSN40p3t1p827wvl54Dn+SgJVFo/o5zMAYSf70NuCjLWALT9EXyC7tWEzffn+fVGxOCZtUjoXtzIcpesaVMI2m9NaroFZRkXvBvSxjm1wuxOCXlmdE0UHY9ikbP8mkvk2pqJzn5Heq0RSqzohL0TMl7ORaZ8SPIQ3TZCpgJWMkl5BnxA+z6Fm/LkIFwFLxjABgZ31RfyHi5Gpqr1gvq2Ead88IAHslzDAhGsDmnVA9I2iYDrb4DLCVl+hPhbJnRL25+HlGuqRU3ub9lspfMUYcT16OtlbrBqCm2fulhtfCekaEQNfPAyF7TeT+yx4M8bQq3+ASAboRyTOiCc+IKJLntm+VbKf2HjwAcG5V23UrBz+QQpgmlaJnHp4RW5EreX9FMfeCe0OBGbIIsQ81FTYMtlCUMtjLx0N4rEwj1Kc96RQbswlYnWEaFi1yGqCBGpohFLBmnNpLYZpcQp4RH1iR8bQ30A+0GemIqqs5AG3pOUiWVYA/eLe+HXFBD6VnRNyEmWYVchNU1+r/mxrDGyOV4/T2JhIOzwjTImD/cKX1vqLSevp1aEacNRFM5DDN/j3W61TDNIxBu+ZWoKvDbuA5jBF/z4hZMTdeDrQ0gfsN+iJEE4nqHqZYsZX1Mmq0/pma2gsEi1jNehmlVphJpE0LQmTTZC21V4hGRWquq9i7z9RaOQzH0apmxO7i1/cRpBkJGabJkWfE2naAl0uQRpjG1kf1O/LxSCqaET/PSzqeESlMY3pAFOOKparZkI2ZrHhGMsymcfPWETmBjBE/xAXa2WFlnaQQphFoC08Gr6kDf+NlsJOW6QtVd+ZQCFirapwXeI1hjHS2gx9oNPbtX+OEFRWBffVKoLdHn63XD5tmxCNM4yZglY0RMYgWl9gEsgBCPa0wUcJextUYCeEZEfv3y1oRn4l9lJTqg7IsYlUFrPIyD0TGEyspBRMDQbtqjPi0yxR5FtnLpUsk//wiWHUt2Kw5vm0B4CxIxlyeavv7gEGjrepvvGK0PkCZBoaLMRO2Aqsg4uFWjxYpLvshErCKtiUQyjOSnoBVEYnaNij1ixu/p6BS8Or3gHDXVXGx9aBhakaUtsk1UML0L+ueESp6NlwhY8QPkU0jNBCxYrtCPwVYw3SriBh0UZptSM6mMSIGULUiKQBWEtef1jsOAds/1JeF2LcmjKggJGPEYQi5FWgSyMaIoLQMKInbl6X7tJKiZ8QcyOUsFi+E0SFi6mJfhjHBOXfO2guE94zImpFDbfZ1QoVp3PvKd+8Af+g/wEePReSHD/m3BXAxRvxn7XWk9moRoGKMPou1vsD60EPAylMRsBapYZoceUa8vDau66Y4WAN2A0Q1MJiLZySRdH6mooa7wohHbam9LkXP1Fl7wxwPtykFMiHDbBp7IT4K0+QS0oz4ISoCipv6mKrsTDsOOC+a0rj3uinCjj4B7PzV0L58sfsKQjeyfav+Ppul6G2aEa/UXjfNiIsxEi/TB3ZbOCBbxoikGeEcXPVSGIMii6fiGTFu1kLfIcI3cn9T8IyYs/OWlIIJQ8fhGUkxTCN5gfjOv+svDrWAi5mOPeDJhDPEo7kMJAP91npu50rWjYTKplFm+HV4Rrw0I0X2MNFQakZEm8IYF+ost2GwGSM+AlE1tTcVz0jac9Mo2TSpGgNZ9oykbAypRFx+k0ROIGPED/XiSFG86ot8oygbFSz0SgFWXAzt9M+bYlXH50I3ImbnzaZXZlSl9drhGfHTjBgCVrmia2lcN/5k70iaTyvMzzMCOL0jCcUz4meM9CphGmGUCI+JLFSNRq2BIEhMKgSspXEfzUjYOiMuIandO6zXjZJOxw21MirgE6bxmUdI1ly5pVEmEuDJJHh3F/i7b1vbCqUZkb0kMXtqeYF4Rlg6mhFfAauSTQNYvys/4ygdAWuJ0xhhahG3VAWk2a4zkqkxwlx+k0ROoDCNH4rbMNVMGl/kG0w2jYEwVCtGSjb375dNY5au9gnTTJwCbN2svxaGSWmpVXcka2GaqP1GmBi0t3dAyabxCdOYM/bKmhEAvNdIu1WLUGkRfX8hwzSspBSa2LYQHQv8wkcBAla+Z4f1ev9esOmzvbc14LIfm+bDGEiSSctAUgdOKOm9XmLBwQHwp34BvuG31vH3CtP4aUZynU2TqicgndReR5hG1owYv6dkiGyadDwjMeka8tCMsFSNkayn9mYoYKVsmrxBnhE/1B9jipk0vsjGSDYLnoVBiFgNWDb3bxOwejzFKWEaPjhoze0izwgsQlc2z8gQaEYAH8+IIe5NQcBqFigTng152xFNyioK6RkpiVvbVAw57mckJVwErHJbZM/I/r3+bVGzXAB3zQhgGZaunhE5TONSgRXQjZHmA/ZtiUFPHUT9PCPy9TukYRphjAQbFyytMI23gJUx5hSGh/GMZKvOiC2soVRgDWMMFFzRM6ozki/IGPFDFVSlkUnjiXyDybFnhA2lZ6Q0bl3EnmEaxTMii1fl1GEhFi7NPEzjMEa0iP1mpWbUqJ6Rvj7viqnCkDLDNELAaghQ3TwjQKBnxJwssKTUGWYqD2EkDboIWI1lvL3Vqn0DgO/f7dsWV8+ImpprTmLnUYEVsBsjciqsPIgMDlgF38REeKL/6gAjT33gl00zVOXg5TaF8oxkObUXgGN+GlP062eMpFNnRBawuhhgDgFritk0WZm1V/o9ZFiBNbCmEZFVKEzjh3KBZjVMI91gslrwLAzVds9IVgWsovBZS5NLaq9HNo0wRkrLwMZVW2580zMi3QTTndbbxTPCGNMH6cQgMOjuGWFl5Xp7uFJRVUYYBCWKgFUsN0WYTL9BRkJ6RvokzYh8DAA9K6WzI0AzItz1ctEzw8iSvSJAeM+ISFtOJu03bsb060Vuj2uYZpyUHmoZCIwx/fcyOKDrU0SI6n9dBRzYB3bsiWJF+wY9wjSsKIdhmhQ8I0grtddHwAo4PY5DJWAtiunf41yqwCp7etII08jHoBBm7aUwTd4gz4gfkaj9Bz1CPCMYNdo+wGd7/yJU46UZUQdhkUkTLwPGSBVXS3WvBLOFadK0nxVjxLxpetUaUeuMAN4Dv6oZKVbDNMqTqjgOQRVY/Twjouy8r2ZE8oyY2TQJcM7BhTEycar+/8BeK43WDTFRYLwMEFV9g2pVBHpGlPTSIikjx+g7q66F9rkLrMq/fgLWYZDaaxd8hmxTkDGiarHMMI1fBVb13AUbAkzTLN2I6IcthKSEPlPU0LBCS+2lME1OIWPEB/1pT7pARoiAlTFm947Ik91lAzFQqk86XkXPRCZNWbn9GIswjfgfidhv5qngphkBvGuNiFBDrNga8LzSaNVsGi/PiOra5uE0I6wkbpWDN7BmBw7pGRF94Fz3ahjGCFuwSD8W/f1W/Q83RI2RomKwSVOt7cqo5zsVzQikwUgO0ygp7w7Xu28F1gJM7VWLhIXBr84I4MxSE/99w0CqMRJy4BW6Ds3FGxRNxzNSYEXPaKK8vEHGSBDi6SoSzXKV1Dx6RgAro6a0zH4DyQLaGeeBHXcK2NHHKx+4h2nM6qvxcrB4mTWYq2GadEM0gOViFkRUz4h7nRFEi6ynQS8vhKPOiFGgTBWwpuoZkWft9fSMBKf2MrnarLFceEZYwzTLMPVL7zWNkSKwM84DW7gY7LhT7Os4jBGX31W83BowvDwjgwNSKXyl/k7oOiM5FLCm4hnJdKK8VMI0YTUjsVh4fYX4HYo2SftgcjgwaP/mOtk2Rqjo2XCFjJEgxAVSOTartUBsk9nlwRgxa5AElIJPa9uz5kBbc4319G5+4FH0TDJGAABV4/XVxbwuIkyTbogGwsUs3ewcnhE1TCOJMMUN2GPg544KrEqYRh0cQgpYXeuMCCqEZ8QnTDMo1xmRBur+PmDfLv31hCnA+Al6P/x0I6YxEgObPA3aZf/mLLuvutldPCOMMcv7pQxWpmCwu9M6NmoFXt/UXiVkkzMBq0vIImhdIPxgGTS5nhn+TKHomeyVSsUIEL9ts89K0bNUvVHZHvwzniiPip7lCzJGghA32GzqRYAC8IzU5n7fXkXPDM0IM/QZ2spLwc5ZAcw6Sv9cPB1n4hkBlAqS3p4RnkzaC4aJm7WnZsQjtVcteqaW0PYRsPLBQcsAKJYqsAqEoTfQ76weK7AJWKXf295PdEOlpBQYVwNmGCO2CQrV9oi2+A1c8mdM0z0ybogJ8zw0J7z9kLkNR3hN+Q7zCtMMgzojnsdHQRf3it+rm2dEhD9F0TOlhL77Rq3XqRgj4nfoVoE1kv8KrHYDNFPPCBkjuYSyaYIwbpBZzaQBFM1I9r0TQbB5C8EnTwc7+fTc7dSr6JnpGdG1IezI+WBHzrc+F4N7pjcHeWATNx2XMum2kE20yIqTB2hGmBKm8fSMiJukXwVWeZK9klKwYmWel9FjrKyU/j6nBwGwCViZZtQ3SSbBd3ysL5/QAKZp4IaHI5xnxOccyE+2Pl4stvgz4AP9YEfMtS8X2+40jJHSUuf0C6E1IzFDgG5kf6SrNQqDaGOIwY8FiVG9iESBwUF3A0bs3/CM8JTDNCkYAaqAVdGMpJzN4jalQCZEUwwT+bWHwjQ5hYyRIMSFmm3PiHxTz3XRM+iVMCPfuSvHOw0ZplG/VhrXB95M3aZuc2u4CVjl+VGiUUkzkmI2jZeA1ZwTxydMI0S9sWKwaNSZ2juq0hpo+7yMEckzIv4n+4EdHwEA2IQp+v/xE/Tjq3hGOOeWMdBvhWk8sYXBvM+VduIy4MRljuWmZqTDqDLr1idHmMZbwMoY06+z/v7c1BkJFaZJQzMCWP100+FoimdEiH/9jIw0PSOsYTr4+3+1ihMq5eDz7hmJZOgNo2yavEFhmiBMYyS7nhFWEgc741yws79kT10dyXgUPeNdLvPSyIw10n3lTIx08A3TDIK/+zZ4R7t9QrhI1PSM8L9/gMQ3L0Hy8bX27Zp1RpRsmkABq49npNOYuM7wmmlquKI0Hhw+klN7AXMg44YxgsnT9P9C+9F8ANyoJ8L37ETy6q8i+cLT+meDujHimIlZgsmDSRqiaNMzIoqxuU0e6RCwyjoR2TCJ2f8XSJjG5tkIm9oLOI1n20aV8KcxfxHzu17SNUbO+yq0H/0CbOan7O0SbcukzkhWip5lqBmJxfSHieLS7FSEJUJDnpEA2BFzwbd96HApZwNtxSVZ32ZBE1T0rMzDGJk6C9oV37JqYqSLj2eEv/1n8D/9Xs8SEedFhDeM7/E/6AMzf/FZ8GWfAxtXo6/nNWuv6hlRjRE/AauYRTduhPCKYvqgI55+S0qtImNeHhth7Kh6g6ZGAAATxsjoMfr2ent078jEKeBvvQJ0toO/8/+A078Q0jMih2lSf6pkpmakTV/gZoykEqaR2zGUnhEW3hhJK7VXXtcvTCOuq7YW/f9oH2MkzXAEY8zuyfWrwJqqpygbs/bKhQzTMEZYtAjav9ykFygkz0hOIc9IANpnV0L7j0et2gpE+ngNwoYxwrzCNIyBLTgezMiySZuYt2eE//UN/X/zfsessyymeCWSSfAXnrXem3VGjJupMHoG+sETCaeA1cym8RGwdtk9I2aFU0FJibUfLy2L6RlxET8yDahvsLbdMEPf78fv6/+3faivJ9KZRQXW0GGaNJ5zxLbFZICuYRofz4haZ0RelhPPyBBVYAX8Bayir4bxyw8ZxsgQeEYc2ObaUeqMpKIZkUW6mWKmHad3ztn02WDTjshOW4jQkDESgrCqdyIALT3NSLZgLlOgm//F03hPtzSni3FTk9y17IzzAAD81f/Rp7nn3PJMqJ4RQPc2mJ4R5Qnarxy8EaZhckE6ydhhWkRKOQ4yRhSxLgDUTgCT+zVrjv7io/d0AeS2rVb7AWtuGj+RoexmT+Op0gwBGeeCpegZkZ9kzddCgD6UAtahrsAK+HtGDD0bb23W3xueEUdqvb0h1stMjBG5z+pEeal4imLFTrFyunjUsSEKGzpbRO6Qbg62SeeEZqSsbGj37+oZUZ7Gerotz4h44hRCz7O/DPbl/wXUTQJ6e8Bf+R89fCH6IlJ7o0VS1dYeZ3luM7XXL0xjeAdkY0QMGsJjEKgZUQWsUoGqSdNsq7KZujHCP94C7PnEEuWKbQvPiF96tTyopRWmEdk0Rt9T1Yyos/bK7SjEME06nhG3+X7GGuL6FsMYMTQjOfGMqALWdCuwZkO8KqidoJ9/cVyIYQFpRojcId8AeRJgEb2ehhj4htgzYp8C3SMDoqfL4RlhS88Gm/dpUyPCPvMF8HX3gL/0LNiiJdZ35RtqcSkw2KF4RuyaEZ5IqkW5LcR8PeVuxkip7T3v69XX37/H7l5WPSPywD1ZCTtOO0Jfr6UZ/K0/WctNY0TUGQmpGcnEM2LOyZOJZkSZOXpIwzT6WQzlfVEFn2HxE7AKgXdrk+7VajeMEV/NyBAYI2l4Rpim6ZlcWUyj1f7lZqCvOy/FJIn0Ic8IkTtkt6nIqOnpspbFC8Az0t9nhV2EZoQxS6wKgB2/VL95tjQDe3bqC4tL7BV6ZRGrWhEzhGbEzKaxhWmUbB0pTJN86D+Q/P6/WZoPzr0FrIBDA8WKS4DJ0/Xvvvw76wPVGPHzeGScTaMMSK6ekbCpvTH7sgLxjNh+I9kO07Q062nRyaTeXzFhpXtDrNcZaUYUAWtR/j0jrLgYrMInREUUJGSMELlDvjkJ3YjwAJTGhzauDyieEZ8S3iK11GNAZUUx3RUMgG83tBVq6q1439vjMmtvcJiGizCN5BlhimfELBHf1wsY7eC7t1vbFuEjtxoVSpgGsEI1pmcCAPr7wJNJcDObxmfQKMrMM+IwdFJO7XXzjORSwBpiH5E0wzRexjMANs7wjBxsAoR4ddToAK1b9j0jjrlpQglYhWaECowd7qQVpnn++efx7LPPoq2tDQ0NDbjkkkswY8YM13XfeOMNPPnkk2hsbEQikUBtbS0+97nP4ZRTTnFdnxjByAOJ8IzkSLwKwNUzwiJRo6BaFAADBgf0WiOA74DK6iaD79pu1exQjRGpJDx3eEYyFLCWKpqR9lZLJyB0A3JFWVXAWjnOmvdH7tPMT4H/z5POtvT3peEZySBMI8goTBOz/8+JgDV4HyxTzYibgWGGaZqttN6gmjxymCaTehpqOfhUNSNTZui/x/nHpd8GYkSQsjHy2muvYd26dVizZg1mzpyJ5557DrfeeivuvvtujB7tvMGVl5fji1/8Iurr6xGNRrFx40bce++9qKiowIIFC7LRB2K4wFw8I0op+CHFtc6I8X/abGD/Xv3JsqNNX+YXaqibqP83jRGlQqqoTdLbA/MpNBUBq1l7xakZYUqYhn+yzVqnpUn/LxdUU5+qvdLUZxxpva6bBDTuNiq89tomyvOCxWJWifpMip6J95mEaUSIrchoU4GEaQInvfPCLSNKIKpDd3WAH9inv/bTiwD245GJXkPNplEErUGwynHQfvBA9jJpiGFLyr7L3/zmN1i2bBlOPfVUTJw4EWvWrEEsFsOGDRtc158zZw6OO+44TJw4EbW1tTjnnHPQ0NCADz74IOPGE8MM+WnMCCHwQ236+xyIzZjb3DTSfDimx8EM0/h4Ruon6S+ER0KdyE6uwqp6RsLMTaNUYAVgeXZMY8R4opWMETO9080zIrxBk50hGgC64M8o881mHGnP1hkIrsAqe0bSKRgVTjOiDFo2z4hLyCaXdUbCGBeR1AZrE9EPtzBNvMw6Vka4zrf6KpA1zQhT+mMWHQPAQqbWkiFCACl6RgYHB7Ft2zace+655jJN0zB37lxs3bo18Pucc2zevBl79+7FhRde6LnewMAABgas+UEYYygtLTVfZwuxrZF8MRRUH+UZS8W8J7v0gZRNaEi7jWH7yMUgzjRoxk1UO/vL4FXjwZachcS7/0//3DBGWDTqvc36yfY2FNsndWMl+nw6rK8PiBbprzX9Zs0iEf29PPeL3M5EwhT2svIKq38lpfpTfmmZvp1i470wngCgpUlfX3hdmAZNDA6TpoC/twnaUcd69ktbtATJX68D+/RJ4H97E+jrBZPDNMU+9SBkYy9alNL5ZIw5jBEWL3NuQxnAmbwf6fusqNiamwYAjGM/FJgZIZrmuw/GmC1MwyI+vy/1u5Omgr/zFjSv62RsNbBnp6VhGj3Gvy2izdCN9HSPDZdF0aYBaFRAjQzdMc8XBXU/HQLy2b+UjJH29nYkk0lUVlballdWVmLvXu8ZP7u7u/H1r38dg4OD0DQNl156KebNm+e5/pNPPoknnnjCfD916lTcfvvtqK6uTqW5oamtrR2S7RYShdBHnkhgt/F6fE01IhWV2L/vE/QDGDP/WJTV1WW0/aA+9rVMwAEAiEZRJ/ZVVwfM0X+LTZVj0Asg1teLPgDF5aNQ7dEmXl2N3dGomQZcUlmJKmnd1rHj0AmgPBpBZFQ5WgGUlJWhqq4OB8vK0A2gorwMo1y2n2hrgbia6qbPMCcfq/78Shxqb8Xo5V9GrK4OHVXVaFO/3HoQtTU1SEQY9il95d/4FpJfuwKR0ZWex4hffCX4+RdDKx+Ffevvw2B7G8aVl6GFcwwCGDe+FiUex6Svo0U/vgDiFRUYm+L57FCMkerJDShStjHQ341G6X3dxInmjTMRLzWPW+2kydBKStBaOQadAMrKyzEmw9+XF82lcfQAKBtVEbiPQ1IGzfj6Cb7nQob/4zVIrlrjuX5T3QT07tlplvqvbJiKcp+2dFZWwvDpYez4WpSmeWx6qqpg+OJQXatvg0WLwPt6URovw7ghOub5phDup0NJPvqXkzojJSUluOOOO9Db24t3330X69atw/jx4zFnzhzX9c877zwsX77cfC9uNk1NTRiUJzHLEMYYamtr0djYaC/CNYIopD7K+9/f2Ah0dCLxsR6uOzS6Cu379qW13bB95J1GGrEWwT6XfSWMp9a+Zn1I7RscdF3PpKYO2LsLANDLYVs3YWTQdBxsAtP0y6y3fwD79u1Dok/3MrS3tqLTZft8n75NxMvQeKDJ7F/LqLHg//h/cBAA9u1D0tiOvRMJ7Nv6vjWXjFtfu3u8+yTo6MSgYQQ1792NpOGpaenoBPM4Jry9w9pF/wD6UjifjDGUK5qRpo4ux75480HrTSSKxkbLNOHJpJ4lVFSExpYWMMbM89DVP4DeNH9fQSSMY93V0+O7D8YY4pJnZH9zE1iYcyHjsX6izB7mPIQIOnzakpTOVUtXN7Q0j02yzfLKNbW0oG58PbjhAe3p6/O/foYhhXQ/HQqGon/RaDSUIyElY6SiogKapqGtrc22vK2tzeEtkdE0zbS0pkyZgj179uCpp57yNEaKiopQ5KHaH4ofAOd8RP6wZAqtjzyZAPbt1jM1ikvAx9c7J9BLdZsBfeSV4/R49tgq9/VKDRFtp6UZ8T1mdZNMYwTFJfZ1pdReLvQbmqavI4qeJROu2+eiAmnZKNvnav+4GuvXNH3enOYDVnZSJJL+eZfTk8VsvtEiz/PEldTeVPerhml4SaljX1z2Hkej9n0wBu3bd1rrcg520ulAxyGwkz8zdL9/KZsmcB+SMcKZlvFv3kSIWAWjx/pfC/JxLIqlf2yk0CtXa6ForKDuOdmk0O6n2SYf/UtJ1RWNRjFt2jRs3rzZXJZMJrF582bMmjUr9HaSyaRNE0IcRpjTnXPwnX/XX0+aOvQ1RgCwURXQvnMXtKu/676CEAEK8WhAhUxWJ+lG1GwaPwGrFiBgNcWr/qJemyCXaVbRspZmZ/XVdDD6xPv6Qs7am8XU3kjEfV9KKqljG5pmKyzGqmuhffUKsPH1KbcnNKlk06QrYA1irPLk6TcvDZC9omdu2UHivOTgmiZGDilLzJcvX44XX3wRL7/8Mnbv3o37778ffX19WLp0KQDgnnvuwS9/+Utz/SeffBLvvPMO9u/fj927d+PZZ5/FK6+8gsWLF2etE8QwQp65d+fHAADW4F6jZihgExrAKse5f6hmbwTNryLSewFnrQY5tVcteiZu2tKEgfxgE5LPPQ7e1wsuCsGVBdRekfdZVQNWYwy4rU3OeWnSQWy/rydUaq+96FmGqb0lcXcRHXMZ/PKNyBJLuQJr9trPZGMkqPqqWEeQxQqsAKxzTxPVESmQ8h3jxBNPRHt7Ox5//HG0tbVhypQp+Na3vmWGaZqbm203kb6+Ptx///04ePAgYrEYJkyYgG984xs48cQTs9YJYhghfhtc8owYT/R5p1SpdRLkGamfZNXVcHhGDMOmz80zYvxPSMbI/30I/K1X9HWMActW8MwNuYjb+AnWxGCyZySDadnNbJ3eHmvyQN+5aTLzjNiMGbe0XsA+iKazj6GAWWGaQOTBO5uDtTwpXHmFvfiYGzZjJJM6Iy7GiOkhIWOECE9ad6qzzjoLZ511lutnN954o+39BRdcgAsuuCCd3RAjEfEUmRi00npz6BnxJVXPyPgJ+oDCk44KrGYabm+vc9ZepQIr5xz8oy36sk+2AVXj9ddBtVekfbLx9aarnrc0gfUaQscMjBGzdorQsAC+x4RFo/pAlEgARZl7RlxRi2wVAqmUg5e8Y1lNn6wcpxsYnAdXXwXsbaUwDVEAkOlK5BbxNLh/j15MK1YM1E3Ib5sMmFoFNsgzUhQDqo0UOL+5aRyz9ioVWFuazDLefPcOoMvQjASVyJfDNLUTbFPJ8w/e0dvoMgdNaGJuxkjAwCW8G5E0NCPyoFha6rGSv2YkL4hqp0E6DQAskoIXJQVYUREgJocLqr4KpY5ENsI0cs0UtbgfQYSgQK5m4rDBuGHx7UYZ9RyJV0OhhmlChAHY8UvB//g82LQj7B/4ztqreEb+LlUjbtwDLgyc8vBhGjZ+guVJaWkCf+ct/fW8hYF98EToXoSgVtMCJl+DPrD19mSuGVHPhbmSNIgWiGaEnf0lsJlHArO9ayeZqLqhbDK2CjjUElx9FbAbChmVg3cpU296RsgYIcJDxgiRW0Ra6zZ9AC6YEA3gDNOEGFC1z10Avvx8p8u9RPKMOASskogXAGRjhCeBj9/XXwdpRmRvzPh6S7fScUj/YxrY3GMD+xC4feEZCfKKANIEdZll07BQYZrC0IywklLgqHDHmanesWwytkovBx/CQ2NO2hvzqagbBjfjiowRIg3IGCFyi3giE2GEME+TuSINzwjgUTpZmrXXSrNVXPQJxTNi1AkRk+SxoNTe0jjYcUsAcKvORHGJ7o0BgBmzg0WwfghjRMxiHMbAEC7/dMI08hN63EvAWoCakVRQJ2jMItoJy5Dcvw/smBOCVxbHMZMQDQDUTgA+tQBMEqGbM2GTMUKkwDC8molhjRi4EwldExHyiTInpOEZ8UTOrunp1v9rzjAN7+sDdm/X3887DvjrX6zvBaX2AtDW/Kt9wdhqwKjgmvG07KqANUzWhWHAsHQyNEIJWAsvTJMSqUyqlyJs/kJE5ocMy4nrMENjhEUiiPyLUrdHDUcSRAjo10LkFnkyuU+f7Jg2Pq+oA2AmYYBYsfn0yYUg1U3AuvMj3TCrHAs279P2baTj1ZBSPFkmehEATGhSDE8NosEGBjvjXODo44Ejjkp9f7JnpMRLwCobI8PvWYqp6d15a0iWPCNuUJ0RIg2G39VMDG/k6piLluSxIU5YNKrfnPv79AWZ1OhgDBhfBzTuAUTarouAlf/9Q/31tNlgE6fCVoA5KLXXbb9jq/VtVNcCtRODVvenRMkQCuHt0BYuBhamV9DQZpiqmU3mDgpPM5ISQylgTQVxrL3quWTCEIaiiJELma5EbhFPS+NqgBlH5rctbsi6kQwHOyYG5W5rgj4A1k06mbSEvNNnA/WTrSf/SMTbO+DHFF0QzI47JfM6Fmoht0yyLkJg94yE0IwMw8HOrMCab8/IzDlgpy2H9vlV2d82CViJNCDPCJFbjJg/W7TEXhq7UCiNA4f0mh+BVSwDYIuWgj+73lrgELAmgR16ijObdgRYcTFQU6/XYImXp2VMsJM/AzZhCjBlZkZtB+AscT/Exohs/DHPOiNSmG8YhmkcVUrzBCsqAvvKZUOzceFtSceYJg5bhuHVTAxr6huA7i6wE5fluyXuyG7rTD0j4+uBqbP0dEvAIWDl/X1msTOIidwmNujGSBohGsBIHZ0+O5NmWzg8I0MbFmGM6cd8cMC7zkghVmBNAdPAHYZenbBoZ34RycqxRqYXQYRj+F3NxLBGu/zfgZ5usKCJvPKFLUyT+eXBjl8KLowRVbzYckD/XxQzjQ82cQr426+lJ17NNmpV2TB1RjKlyDBGwoRphqExEps9F+xTC4BjT8p3U4YMVlMHbTlNAUKkRgH6yYmRDCuKFa4hAr12h0kWBJJs4WJp7hJFwNq8X/8/psoMybCjjtXnLZn5qYz3nTHqfDs5yHxi02YDo0br4l/XFYZ3No0WL0Pk6puhnXJmvptCEAXF8LuaCWIoiWdPwAoAbNRoYMHxwMbXrGnehTEihK3jrOnf2ZSZ0P7jUTDVK5EPimLW5GtAZrO7hkS76gbwwQG7mFVmmBsjBEG4Q1czQcjYPCPZuTy0i/83sPRsa+4SRS/A5OnfgcIwRGBkfsSKrYquQy1gFfv02Q9jzJopeRiGaQiCcIfCNAQhk+UwDaDPs8KOnG9lx6hZRGOqnV8qFGTDKAfGSChEFVbyjBDEiIGMEYKQybKA1RW1xoTiGSkoCtEYEUYdeUYIYsRAxghByGSx6JkXan0VU0tSiBSiMWLO70LGCEGMFMgYIQgJFs++ZsSBwzNCxkhKiPRe8owQxIiBjBGCkMmBZ8RR8KqgwzRS4bMcZNOEgpFmhCBGGmSMEISMLGCNDJExIodpykYVTPaMK3JJ+EKZmE4jzwhBjDTIGCEIGdkzUpSDME0he0UAMJtnJAcVWMPASDNCECMNupoJQqZyLFA+Cigt0+d5GQpkz0gh60UAoMTy2uSiAmsoKExDECMOupoJQoIVxaDd/F9DO9BJRo5a8KzgiMkC1kLxjFBqL0GMNOhqJggFluaMuaGJDCPPiC2bpkA8I4Yxx8gYIYgRA2lGCCLXyDPPjilwz0hBpvaKMM0QhdEIgsg5ZIwQRK6RBlE2bjh5RgrEGDHLwReIp4YgiIwhY4Qgco0sYC3keWkAm4C1cOqMUGovQYw0yBghiFwjBKxM07N3ChgWK0TPCKX2EsRIg4wRgsg1Y6v14mrTjwArdN1DSQEaIxMa9LbU1OW7JQRBZAl6tCCIHMPiZdBuW1s4RcT8kIueFYgxov3j/wH6esDi5fluCkEQWYKMEYLIAyxeFrxSISCXgy8QY4RFIgAZIgQxoqAwDUEQ3gjPCNMolZYgiCGDPCMEQXgzrhqYdRTYuGowUd+DIAgiy5AxQhCEJ0yLIPJv38t3MwiCGOFQmIYgCIIgiLxCxghBEARBEHmFjBGCIAiCIPIKGSMEQRAEQeQVMkYIgiAIgsgrZIwQBEEQBJFXyBghCIIgCCKvkDFCEARBEEReIWOEIAiCIIi8QsYIQRAEQRB5hYwRgiAIgiDyChkjBEEQBEHkFTJGCIIgCILIK2SMEARBEASRV6L5bkAqRKND09yh2m4hQX0c/oz0/gHUx5HASO8fMPL7mM3+hd0W45zzrO2VIAiCIAgiRQ7rME1PTw+uvfZa9PT05LspQwb1cfgz0vsHUB9HAiO9f8DI72M++3dYGyOcc2zfvh0j2TlEfRz+jPT+AdTHkcBI7x8w8vuYz/4d1sYIQRAEQRD5h4wRgiAIgiDyymFtjBQVFeHLX/4yioqK8t2UIYP6OPwZ6f0DqI8jgZHeP2Dk9zGf/aNsGoIgCIIg8sph7RkhCIIgCCL/kDFCEARBEEReIWOEIAiCIIi8QsYIQRAEQRB5ZWQX2A/g+eefx7PPPou2tjY0NDTgkksuwYwZM/LdrJR58skn8eabb2LPnj2IxWKYNWsWLrroItTX15vr3HjjjXjvvfds3zv99NNx2WWX5bq5afH444/jiSeesC2rr6/H3XffDQDo7+/HunXr8Nprr2FgYADz58/H6tWrUVlZmfvGpskVV1yBpqYmx/IzzjgDq1evHnbn8L333sMzzzyD7du3o7W1Fddccw2OO+4483POOR5//HG8+OKL6OrqwuzZs7F69WrU1dWZ63R2duKBBx7A22+/DcYYFi1ahIsvvhglJSX56JIDvz4ODg5i/fr12LRpEw4cOIB4PI65c+di1apVGDt2rLkNt/O+atUqnHvuubnsiidB5/EnP/kJ/vjHP9q+M3/+fFx33XXm+0I+j0H9W7lypev3LrroInz+858HUNjnMMz4EOb+2dzcjPvuuw9btmxBSUkJlixZglWrViESiWSlnYetMfLaa69h3bp1WLNmDWbOnInnnnsOt956K+6++26MHj06381Liffeew9nnnkmpk+fjkQigUcffRS33HIL7rzzTtvFvmzZMpx//vnm+1gslo/mps2kSZPwne98x3yvaZZj7+GHH8bGjRtx9dVXIx6PY+3atfjRj36Em2++OR9NTYvvf//7SCaT5vtPPvkEt9xyC0444QRz2XA6h319fZgyZQpOO+00/PCHP3R8/vTTT+N3v/sdrrjiCtTU1OCxxx7DrbfeijvvvNPs149//GO0trbi29/+NhKJBO6991787Gc/w1VXXZXr7rji18f+/n5s374dX/rSlzBlyhR0dnbioYcewg9+8APcdttttnVXrlyJ008/3XxfCIO0IOg8AsCCBQtw+eWXm+/VydEK+TwG9e/nP/+57f2mTZvw05/+FIsWLbItL9RzGGZ8CLp/JpNJfP/730dlZSVuueUWtLa24p577kEkEsGqVauy01B+mPLv//7v/P777zffJxIJftlll/Enn3wyf43KEocOHeIrVqzgW7ZsMZfdcMMN/MEHH8xfozLkscce49dcc43rZ11dXfyCCy7gr7/+urls9+7dfMWKFfzDDz/MVROzzoMPPsivvPJKnkwmOefD+xyuWLGCv/HGG+b7ZDLJ16xZw59++mlzWVdXF1+1ahV/9dVXOeec79q1i69YsYJ//PHH5jqbNm3iK1eu5AcPHsxd40Oi9tGNjz76iK9YsYI3NTWZyy6//HL+m9/8ZqiblxXc+njPPffw22+/3fM7w+k8hjmHt99+O7/ppptsy4bTOVTHhzD3z40bN/KVK1fy1tZWc53f//73/B/+4R/4wMBAVtp1WGpGBgcHsW3bNsydO9dcpmka5s6di61bt+axZdmhu7sbAFBeXm5b/sorr+DSSy/Fv/7rv+KXv/wl+vr68tG8tGlsbMTXv/51XHnllfjxj3+M5uZmAMC2bduQSCRs53PChAmoqqoatudzcHAQr7zyCk499VQwxszlw/0cCg4cOIC2tjbMmzfPXBaPxzFjxgzznG3duhVlZWWYPn26uc7cuXPBGMPHH3+c8zZng+7ubjDGEI/HbcufeuopXHLJJfjmN7+JZ555BolEIk8tTI/33nsPq1evxlVXXYX77rsPHR0d5mcj6Ty2tbVh06ZNOO200xyfDZdzqI4PYe6fW7duxeTJk21hmwULFqCnpwe7du3KSrsOyzBNe3s7ksmkQ09QWVmJvXv35qdRWSKZTOKhhx7CEUccgcmTJ5vLTz75ZFRVVWHs2LHYuXMnHnnkEezduxfXXHNNHlsbnpkzZ+Lyyy9HfX09Wltb8cQTT+D666/Hj370I7S1tSEajaKsrMz2ndGjR6OtrS0/Dc6QN998E11dXVi6dKm5bLifQxlxXtSQqHzO2traUFFRYfs8EomgvLx8WJ7X/v5+PPLIIzjppJNsxsjZZ5+NqVOnory8HB9++CEeffRRtLa24mtf+1oeWxueBQsWYNGiRaipqUFjYyMeffRRfO9738Ott94KTdNG1Hn84x//iJKSEpumBBg+59BtfAhz/2xra3OMl+LazdY5PCyNkZHM2rVrsWvXLnz3u9+1LZdjmZMnT8aYMWPw3e9+F42Njaitrc11M1Pm6KOPNl83NDSYxsnrr79e0LqJdNmwYQMWLFhgEzoO93N4ODM4OIi77roLALB69WrbZ8uXLzdfNzQ0IBqN4r777sOqVauGRdnxk046yXw9efJkNDQ04Bvf+Aa2bNlie9oeCWzYsAGLFy923HOGyzn0Gh8KgcMyTFNRUWFa7DJu1t9wYu3atdi4cSNuuOEGjBs3znddkTXU2NiYi6ZlnbKyMtTX16OxsRGVlZUYHBxEV1eXbZ1Dhw4Ny/PZ1NSEd955B8uWLfNdbzifQ3FeDh06ZFsun7PKykq0t7fbPk8kEujs7BxW51UYIs3Nzfj2t7/tCNGozJw5E4lEwjWzajgwfvx4jBo1yvxdjpTz+P7772Pv3r2uIRqVQjyHXuNDmPtnZWWlY7wU1262zuFhaYxEo1FMmzYNmzdvNpclk0ls3rwZs2bNymPL0oNzjrVr1+LNN9/E9ddfj5qamsDv7NixAwAwZsyYIW7d0NDb22saItOmTUMkEsG7775rfr537140NzcPy/O5YcMGjB49Gsccc4zvesP5HNbU1KCystJ2zrq7u/Hxxx+b52zWrFno6urCtm3bzHU2b94MzvmwScEXhkhjYyO+853vYNSoUYHf2bFjBxhjjtDGcOHgwYPo7Ow0f5cj4TwCwEsvvYRp06ZhypQpgesW0jkMGh/C3D9nzZqFTz75xPbw8M4776C0tBQTJ07MSjsP2zDN8uXL8ZOf/ATTpk3DjBkz8Nvf/hZ9fX22GP1wYe3atXj11VfxzW9+E6WlpaYFG4/HEYvF0NjYiFdffRXHHHMMysvL8cknn+Dhhx/GkUceiYaGhvw2PiTr1q3Dpz/9aVRVVaG1tRWPP/44NE3DySefjHg8jtNOOw3r1q1DeXk54vE4HnjgAcyaNWvYGSPJZBIvv/wylixZYsvfH47nUBiMggMHDmDHjh0oLy9HVVUVzjnnHPz6179GXV0dampqsH79eowZMwYLFy4EAEycOBELFizAz372M6xZswaDg4N44IEHcOKJJ9rCV/nEr4+VlZW48847sX37dlx77bVIJpPmtVleXo5oNIqtW7fio48+wpw5c1BaWoqtW7fi4YcfxuLFix0C9Hzh18fy8nL86le/wqJFi1BZWYn9+/fjv//7v1FbW4v58+cDKPzzGPQ7BXRD+S9/+Qu++tWvOr5f6OcwaHwIc/+cP38+Jk6ciHvuuQcXXngh2trasH79TxpPfAAABtVJREFUepx55plZC0Md1rP2Pv/883jmmWfQ1taGKVOm4OKLL8bMmTPz3ayU8SrKc/nll2Pp0qVobm7Gf/7nf2LXrl3o6+vDuHHjcNxxx+GLX/xioMu4ULj77rvx/vvvo6OjAxUVFZg9ezYuuOACUyshivb8+c9/xuDg4LAsegYAf/vb38x6N3JRouF4Drds2YKbbrrJsXzJkiW44oorzKJnL7zwArq7uzF79mxceumltn53dnZi7dq1tmJZl1xyScHUcPDr44oVK3DllVe6fu+GG27AnDlzsG3bNqxduxZ79uzBwMAAampqcMopp2D58uUFozXw6+OaNWtwxx13YPv27ejq6sLYsWMxb948nH/++bZrr5DPY9DvFABeeOEFPPTQQ/j5z3/uuN4K/RwGjQ9AuPtnU1MT7r//fmzZsgXFxcVYsmQJLrzwwqwVPTusjRGCIAiCIPLPYakZIQiCIAiicCBjhCAIgiCIvELGCEEQBEEQeYWMEYIgCIIg8goZIwRBEARB5BUyRgiCIAiCyCtkjBAEQRAEkVfIGCEIgiAIIq+QMUIQxLDm8ccfx8qVKx2TsREEMXwgY4QgCIIgiLxCxghBEARBEHmFjBGCIAiCIPJKNN8NIAhieNDS0oL169dj06ZN6OrqQm1tLZYvX47TTjsNgDX76T//8z9jx44d2LBhA3p7e3HUUUfh0ksvNadjF7z++ut46qmnsHv3bpSUlGD+/Pm46KKLHNPK79mzB4899hi2bNmC3t5eVFVV4fjjj8dXvvIV23rd3d34xS9+gbfeeguccyxatAiXXnopiouLh/bAEASRMWSMEAQRSFtbG6677joAwJlnnomKigr89a9/xU9/+lP09PTgs5/9rLnur3/9azDG8IUvfAHt7e147rnncPPNN+OOO+5ALBYDALz88su49957MX36dKxatQqHDh3Cb3/7W3z44Yf4wQ9+gLKyMgDAzp07cf311yMajWLZsmWoqalBY2Mj3n77bYcxctddd6G6uhqrVq3Ctm3b8NJLL6GiogIXXXRRjo4SQRDpQsYIQRCBrF+/HslkEj/84Q8xatQoAMAZZ5yBu+++G7/61a/wmc98xly3s7MTd911F0pLSwEAU6dOxV133YUXXngB55xzDgYHB/HII49g0qRJuOmmm0wDZfbs2bjtttvw3HPPYeXKlQCABx54AABw++232zwrF154oaONU6ZMwT/90z/Z2rFhwwYyRghiGECaEYIgfOGc44033sCxxx4Lzjna29vNvwULFqC7uxvbtm0z1z/llFNMQwQAjj/+eIwZMwabNm0CAGzbtg2HDh3CmWeeaRoiAHDMMcdgwoQJ2LhxIwCgvb0d77//Pk499VRHiIcx5minbBABunHT0dGB7u7uzA8CQRBDCnlGCILwpb29HV1dXXjhhRfwwgsveK4jQit1dXW2zxhjqK2tRVNTEwCY/+vr6x3bqa+vxwcffAAA2L9/PwBg0qRJodqpGizl5eUAgK6uLsTj8VDbIAgiP5AxQhCEL5xzAMDixYuxZMkS13UaGhqwe/fuXDbLgaa5O3pF+wmCKFzIGCEIwpeKigqUlpYimUxi3rx5nusJY2Tfvn225ZxzNDY2YvLkyQCA6upqAMDevXtx1FFH2dbdu3ev+fn48eMBALt27cpORwiCKFhIM0IQhC+apmHRokV444038Mknnzg+V8uw/+lPf0JPT4/5/i9/+QtaW1tx9NFHAwCmTZuG0aNH4w9/+AMGBgbM9TZt2oQ9e/bgmGOOAaAbQUceeSQ2bNiA5uZm2z7I20EQIwvyjBAEEciqVauwZcsWXHfddVi2bBkmTpyIzs5ObNu2De+++y4efPBBc93y8nJcf/31WLp0KQ4dOoTnnnsOtbW1WLZsGQAgGo3iwgsvxL333osbb7wRJ510Etra2vC73/0O1dXVtjThiy++GNdffz2uvfZaM7W3qakJGzduxB133JHz40AQxNBAxghBEIFUVlbie9/7Hp544gm88cYb+P3vf49Ro0Zh0qRJjjTb8847Dzt37sRTTz2Fnp4ezJ07F6tXr7YVH1u6dClisRiefvppPPLIIyguLsbChQtx0UUXmUJYQE/XvfXWW/HYY4/hD3/4A/r7+1FdXY0TTjghZ30nCGLoYZz8nQRBZAFRgfXqq6/G8ccfn+/mEAQxjCDNCEEQBEEQeYWMEYIgCIIg8goZIwRBEARB5BXSjBAEQRAEkVfIM0IQBEEQRF4hY4QgCIIgiLxCxghBEARBEHmFjBGCIAiCIPIKGSMEQRAEQeQVMkYIgiAIgsgrZIwQBEEQBJFXyBghCIIgCCKv/H+TNyGHZ3fVbAAAAABJRU5ErkJggg==", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjUAAAG0CAYAAADKEdZ4AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAACOPUlEQVR4nOzdeXhTVfoH8O+52Zq0TdN9odCFtoBQNlGQRdkUEUbBBREXFEVHHXV0XH6Ku6DiuODGjDOiguOGKAqCuLAogogsKhWkYIFSuqVLmrZp0yT3/P64zaWhW5Jma3k/z8NDk9x7c3IoyZtz3vMexjnnIIQQQgjp5oRgN4AQQgghxBcoqCGEEEJIj0BBDSGEEEJ6BApqCCGEENIjUFBDCCGEkB6BghpCCCGE9AgU1BBCCCGkR6CghhBCCCE9AgU1hBBCCOkRlMFuQKBVV1fDbrf7/Lrx8fEwGo0+vy5pG/V3YFF/Bxb1d2BRfweWp/2tVCoRHR3t3rHeNqq7stvtsNlsPr0mY0y+Nu064X/U34FF/R1Y1N+BRf0dWP7ub5p+IoQQQkiPQEENIYQQQnoECmoIIYQQ0iNQUEMIIYSQHoGCGkIIIYT0CBTUEEIIIaRHoKCGEEIIIT0CBTWEEEII6REoqCGEEEJIj0BBDSGEEEJ6BApqCCGEENIjUFBDCCGEkB6BghrS7XC7DdzhCHYzCCGEhBgKaki3wo2lcPz9alQsvJd21CWEEOKCghrSrfAfNwONDWjcuRV897ZgN4cQQkgIoaCGdCt8z3b5Z3HlW+BWaxBbQwghJJRQUEO6DV5WDJw4BigUUMQmAFVG8K8+DXazCCGEhAgKaroZbqkHP5h3WuaTOEdpWL9cGObfLd331SfglcZgNosQQkiIoKCmm+Fr3of4/ENSbslphu/5EQDAzhwN7djJQM4goKkJfNXbQW4ZIYSQUEBBTTfDiwulv3f9EOSWBBavNAJHDwGMgQ0dBcYYFFfdDDABfNcP4Afzgt1EQgghQUZBTXdTXyf9ffA38KbTJ0mW721OEM4aABYVDQBgvTPAzr0AACB++F9wkWrXEELI6YyCmu6mvlb6u6kJOI1GJ/ju5qmn4aNd7meXXAPowoGiI+Dffx2MphFCCAkRFNR0N86gBgDftyuIDQkcXlMN/HkAAMCGn+PyGIvUg118tXTc5/8Dd45kEUIIOe1QUNONcLsdaGw4eXvfrtNiFRTfuwPgHMjIAYuJb/U4Gz8VSOkD1NWCr3k/8A0khBASEiio6U4szaMQjAFKJVBRBpSeCG6bAkBeyj3snDYfZwoFhNnzpWO3rAc/cSxgbSOEEBI6KKjpTpxTK9pwaTkzAL7v5yA2yH3cXA1xx2ZptMmT8+rMwMF9AAB2ZttBDQCwAUOAYaMAUYT40ZunxQgWIYQQVxTUdCfOfJrwCLDcEQAAvm93EBvkPr7qHfBlL4GvXuHZeb/+DIgikJoOlpDS4bHCFfMApQo48Cvwy09daS4hhJBuSOnNSRs2bMDatWthMpmQlpaGefPmISsrq93j6+vr8cEHH2Dnzp2oq6tDfHw85s6di+HDhwMAVq5ciVWrVrmck5KSgiVLlsi3m5qasGLFCmzfvh02mw1DhgzBTTfdBIPB4M1L6J6cIzXhkWC5I8A/ehM4tB+8wQKm1QW3bZ3gBfnS3xvXgo+7ACwp1b3znFNPp6x6aguLTwK7YCb4+pUQVy6DMGg4mErtfaMJIYR0Kx4HNdu3b8eKFSswf/58ZGdnY926dVi0aBGWLFmCqKioVsfb7XYsXLgQer0e99xzD2JiYlBRUQGdzvVDuHfv3njkkUfk24LgOoi0fPly7NmzB/fccw90Oh2WLVuGF154AU899ZSnL6Hb4vVm6YfwCLDEFCAhBSgvBg78ArjxoR8s3GqV2gkADgfEj5ZBcddjnZ/XYAH27wXgXlADAOyiy8G3bwQqysC//gxs2iyv2w00t/3PA0BcIhCXCCbQ4CYhhIQqj4OaL774ApMmTcKECRMAAPPnz8eePXuwefNmzJgxo9XxmzZtQl1dHZ566ikoldLTJSQktDpOEIR2R10sFgs2bdqEu+66C4MGSbkkt912G+6++27k5+cjJyen1Tk2mw02m02+zRiDVquVf/Yl5/V8fd1Wz1NfBw6AhUeCMQY2eAT4t2vA9+2GcOYYvz53lxQXSquXwrSAzQbk7QbftwvC4LM6PI3v2wXY7UBiL7BefVr1c1v9zcK0wBXXQ/zvC+DrVoJnDYDQf7BXzeYNFogvPQoUHJTuUGuAlN5gKWlgvdKAXmlgqWlAVIzf/+2DKVC/30RC/R1Y1N+B5e/+9iiosdvtKCgocAleBEFAbm4u8vPz2zxn9+7dyM7OxrJly7Br1y7o9XqMGTMGM2bMcBmNKS0txS233AKVSoWcnBzMmTMHcXFxAICCggI4HA7k5ubKx/fq1QtxcXHtBjWrV692mdLKyMjA4sWLER/fekmwryQlJfnt2gBQIwBmAOEJSYhOTkbj+Atg/HYN2P69SEpKCtn/lHW//YRqAJr+uVD37Y/aT1ZAWPUOkiZOBVOp2j2vYv8eNACIPO8CGFJa59O019/8ktmo3LcLDTu+A3/1KcQ89Ro0A4d61GaxsQHGlx6Bo+AgmEYDLnKgyQocPQx+9DBapiELEXoo0/oibPgoaM+9AKqU3h49FwBwhx3WX3fB8sNGKKJjoL/6lpAbFfL37zdxRf0dWNTfgeWv/vYoqDGbzRBFsdWIisFgQHFxcZvnlJWVwWg0YuzYsXjwwQdRWlqKN998Ew6HA1dccQUAIDs7G7fddhtSUlJQXV2NVatW4dFHH8ULL7wArVYLk8kEpVKJ8PBwl2tHRUXBZDK1+bwzZ87E9OnT5dvOD3yj0Qi7hytwOsMYQ1JSEkpLS/266sZRVgIAqGcCGktKwGNTAE0YxKoKlOzcBtanr9+euysceb8AAJoSUmCfMA34di3sxYUo/t9/IFx4aZvncGsjHD9vAwBYcgajoaREfsyd/uZz7wSrNYP/vhflj94BxT0LwTJbB79tnttkhfjKk+B//AZowyH8YyHQOwMwlkjLxU8Ugp84Jv1cXgyxzgzr73th/X0vat79F5CeBeGsc8HOGttmXR35eUQROLwf4s7vwXdtA+rM8mO1dXVQzLjGrfa2e31LPZguvPMDOxGo328iof4OLOrvwPKmv5VKpdsDEl4lCnuCcw69Xo9bbrkFgiAgMzMTVVVVWLNmjRzUDBs2TD4+LS1NDnJ+/PFHTJw40avnValUULUzCuCvX1zOuX//U9Q1r37SRUjPo1QCA4YAv/wE8defIfTO9N9zdwEvOiL90Csd0GjBLr0O/O2XIX7xITBqvLyXk8s5eXukkZHYBPA+mdL01anHdNTfShXYrQ+Bv/okcHAfHEsehXDPQrC0jgM/brNBXPo08MdvgEYL4a7HAOc5ib3AEnsBw0eDycc3AaUnwI/kg+/eBhz4DTh6GOLRw8DHbwFZZ4CdPQ7szNFg+mipvUcPge/cCr5rK2CqOvnkEXog+wxg7w7wLz6CIykVwsjzOundNl6D6AB/+2XwHVvAxkwCu3K+TxLJ/f77TVxQfwcW9Xdg+au/PQpq9Ho9BEFoNTpiMpnazYcxGAxQKpUuU029evWCyWSC3W6X82xaCg8PR0pKCkpLS+Vr2O121NfXu4zW1NTUnFarn3iL1U9OLPdM8F9+As/bDUy/Mkgtax/nHDh+FIC0ASUAsFETwLd8CRzJB/90BdgNd7U+r0XBPW+n1ZhGA+FvD0N8+XHg8AGISx6F8I9FYKnpbbfVboP4xmIgbw+g1kC481Gwvv07fg6VGuidIb22c6eAm03gu7dLAUv+78Dh/eCH94N/8F8gZyBQWS4VTXTShoMNHwV21rlA/8FgCgXEj98G/3o1+DuvgCckg2W4N8IESKM//J1XwXdskW5v2wj+xz4IN9wF1i+345Pbul6tGXz7RpgjwiHqY6TKzTHxbv+bcM6BqgqguHlkq2UQ1x6FAkhMAUtJA1L6+GS0iRByevAoqFEqlcjMzEReXh7OPvtsAIAoisjLy8OFF17Y5jn9+vXDtm3bIIqiHNiUlJQgOjq6zYAGABobG1FaWopx48YBADIzM6FQKLBv3z6MGjUKAFBcXIyKioo282l6rOY6NSw8Qr6LDRoh5XcUHASvNYNF6oPTtvZUVQAN9dIHVfMybiYIEGbPh/jMfeDbN4KPn+rywc1tNvDfpKKCHRXccwcL00K48zEp4fdIPsQXH4Fw3zNgya5LyrnDAfHNF4BfdwIqNYS/PQyWM9Dz59MbwCZcBEy4CLyqAnz3NvCftwJH8uUiglBrwIaOBDtrHDBweKu8InbZdeClRcBvP0N8fRGEh14Ai4nr9Lk55+D/Wwr+4yZAEMAungP+wzdARRnE5xeATb4EbOY1YGpN59ey1IF/8zn4N2sAawNqWj4YppWCjV5pJ//u1QcAA04cAy8udPm75dYenpC/w8XEASlpYL36NP+dBiSnuvU6CCGnF4+nn6ZPn47XX38dmZmZyMrKwvr162G1WjF+/HgAwGuvvYaYmBjMmTMHAHDBBRfgq6++wjvvvIMLL7wQpaWlWL16NaZOnSpfc8WKFRgxYgTi4uJQXV2NlStXQhAEjB07FgCg0+kwceJErFixAhEREdDpdHjrrbeQk5NzWgY1LiM1MXFAajpQdBT89z1go8YHpWntck49JaW6fHizzH5g50wE/3ETxA/+A+H/njuZGPvHb0CDBYiKATI7HilxB9PqINz1OMQXHwYKCyC+8DCE+5+Wi/lx0QH+1hJg93ZAqYRw24NSheKuPm9MHNj5lwDnXwJuLAX/bRegN4ANHgGmCWv/PEEB4aZ/QHz2fqC4UAps7n+mw3M45+Af/hd869cAE8BuvAfC2eeCT5oO/vHb4N9/Bf7t5+C/74Ew7+9g6dltX6exQaol9PVnJ7fl6J0JXWY2LIcPAqVFUpBScBC8eVVYpwPICkXzCrY0IC4BYJ0kQDdZwUuOAycKAVOlFBhXVUijkc7nYwIQnwT0cgZXzUFPQgpYO1+WeIMFKJbyoeS/Txxz2SS2XboIsGGjwEaMBfrlgikUnZ9DCAk4j4Oa0aNHw2w2Y+XKlTCZTEhPT8dDDz0kTwNVVFS4DE3HxcVhwYIFWL58Oe677z7ExMRg6tSpLiuoqqqq8PLLL6O2thZ6vR79+/fHokWLoNefHHWYO3cuGGN44YUXYLfb5eJ7p5U2pp8ASIX4io4C+3YBIRbU8ONSUOOcemqJXXod+J4fpWmoHVvARkv5Uyennkb5bAUQC4+A8PcnIb6wADhxTAps7nsGiIkHX/E6+M7vAIUCwi0PgA060yfP6fL88Ulgk6Z3fqDzeK1Omjp7+l6g8E+Iby+BcPP9bfYH51yq2LzpC+nc6++AcPa50s9hOrBrbwcfOhLi8leBkuMQn7kPbNqVYBddIQcAvMkKvuVL8A2fALXN4zLJvSFccjXY8HMQ26sXmkpKINpsQHmxHBDwE4VA8THAKE0VIy5RWuqeknYy4EhMAVO2v8qtI7y+rkUg0vx8zkCkvFhqy94d0rEAoFACSb3kUSQ0WE6OGFUZvWoDAKDODL71aylojIwCGzFGmjLs29/nq9TEA7+i4Vg+uE4PHhMfcqvgehIuOsAP5sFaVQZuiJf21TtNcM6B6gpp4UOdWSqImtK7wy9P7V6r0QIUHwc/cUwarR5yth9a7B7GT7PMKKPR6FK/xhcYY0hOTkZJSYn/kpAdDoh/nQkAEF78n8s0Ez+0H+Jz/wfoIiC89C6YEDrfIsV/LwbfvQ3s8ushTGm90knc8An4J8uBqGgIC/8FqDQQ770OqKuFcM9TbY6YdKW/ubka4j8fkjYCjUsEyx4oTdcwAcIt94GFWL0fnv87xBcfARx2sL/MhnDxnFbHiJ/9D3zdSgAAu/Y2COe2PRXM68zg//uXlNAMAGlZEObeAX74gHR+TXO+S0Iy2F+ukhKcBYVb/c2tVun5Nf6fEuKcAzXVUrBTfHI1GooLAWtjxycbYluP7kTFAJ19lpUUge/6AXz3dteRneg4aZXbWeOAtKwul1Xge36E+K9nTt6h1jRP8bWYemtuc6iWcOgOOOfA3h8hfv6+9HsDANGxYGeOBTt7HJCe3aP6l9fWuHwJkf+/NFhaHxyf1Hp6OakXmFIlLYwoKWr9/66y/OT5uSOguPPRdtvizfu3SqUKndVPxEcs9Sd/PjVxMrMfoIuQpgsKDgJZZwS2bR3gRUcBACy19UgNALBJF0vffstLwNd9DHbGUGmVV0SkvGmnLzF9NIR7FkL854OAsRS8ogxgDOzGu0MuoAEAljMQ7JpbwZe/Cr72Q4jJfSCcNVZ+XPzio5MBzeyb2w1oAIBF6IFb7gd2fg/+/r+BY4chPtkiSTsmHmz6lWDnTGx3CqfdawcgmJGfizHAEAMYYqTfl2ZcFKXRmBPNwU7xcSn/p1fayTfoFvloHjHEgg0YAn7VLcCBX8F//h78l5+A6grwrz+TpusSe0G4+V6vSyvw+jqI7/8bAKCIT4KjurK5NtIh8KOHpGOcB+siwAYMAbvyJrDoWO9e02mIcw7k7Yb42XtA4Z/SndpwMIGBV1dKU7Tffi594TlrnBTg9ErvNgFOu1OsztHXUzVPDSNCL00tm03SqKuxFPzXndI1ncdFRQPVVQAX276WIUYKvDtZXOFvFNR0F85vh9rwVvP5TKEAGzgM/Oet4Pt2g4VIUOOyPUI7K46YSgVh1k0QX3tKekM5cUy6f8hIv+UtsOhYCP9YJAU2VUawuXd4tXQ6UISx50MsLpQSd99eAh6fCJaeDfGr1eCfvwcAYJffAMGN6S3GGNjI88BzBkF85xVpG4qoGLBpV4CNvaDDYoihjgnCye0shnRcrdrr51AqgdwzpVWHtiYgb4/0/+7Xn4CyExD/9SyER5Z4tWKLr3pbGoFK6oXkf61ESbkRvLz4ZF2k5m/HKC8GLHVSEvqBX8Dm/BXs7HO7zQevL3DRARQdA2LipGDdnXMO/Arx8/eAP/+Q7tBowc6/GMIFM5DcJw3F364H39kcrFaUgX+5CvzLVUByb7ARY6XyCLGtq+EHC68oAz+03zUpv70pVsaaR2CaRyedU8SJyS5Tw7y2pkUwdHIkFA31Um4bIH2BTm0xxez8+5S0iGChoKa7aLFDd5sGjwB+3iolo868NnDt6kjxMam+TGRUm7VoZINHAIOGS0up9+0CALAz/buXFYuNh/DE60CtCSwu0a/P5Qvs8uvBS08A+3ZBfH0R2LgLwNd+KD12ydUQpsz07HrRsRD+/jhwvEBK4qaVRB5jKjUwbBTYsFHg9bUQn7pb+jB871/ATf/wKMjgB36VVqoxBsXcO8HUGimoT0qV/n1a/H/gtiYp4f2jN6V8tDdfkHalv/qvbn/Ad3d85VvgG9dKN6KiXadLUvpIH7JhUm0mfni/NDIjrz5Ug02YBjblMrBIvRToq9QQho4EH3I2uLUR/Ldd4D9/D+zbDZQcB1/7AfjGNRCeeA3MEPyRMb53h1R+wuFo/WB0nGuwkdIHSO7j1mgqi4ySEuFblH+Qcm8qgapyIC4JiIoO6QCagpruoo2VTy2xgcPBGQOKjoBXV4bEkLRz6qm9URonxpg0WnPgDuk/qVYH9O/66qPOMI0G0IR+QAM0r4iafy/EZ+5rfpNtDmimzYLgZX0ixhgQolWouxsWHin9+zz3f+A7vwfOGAY2ZpJb53JrI8R3X5euM34qWHbHI61MpQb69ofwwGLwLz8G/+IjKd/n0O8QrvsbWCd7qgULt9vAt6wHOMAmX+z1ByMvOgK+ad3JO2qqgZpq8AO/So87749NkKZVjh2WbiuVYOdeCDb1cjBDTLvXZ5owsLPGAmeNBbfUS3XAvvxYKrL51WdgV97oVbt9he/bBfGN56T3yrQssMx+zVOsfZrrOnk5xdoOxphUVsGNshKhgIKabqKtwnstscgoICNHWmq7bxfYuVMC2Lp2dLDy6VQsORVs4nTwbz6XCu5142kQf2FaHYQ7HoH49D+AulqwC2aCXXJ1sJtFmrG+/cEuuRp89bvgH7wB3reftKKkE/zz96Q8hpg4sEuvc//5FAqw6bPBc0dAXPaStLLt1afAxl0ANmuePFLhC1x0dGkBAj9RCPGtl07msUTowc6Z4Pl1OIf44ZtSXseZoyFcf5cU5J86XVJTJSWvVpZLNZvGTJZW/MV6tvcf04WDjZ4IrjdAfPlx8O+/BL/ocun9Ngj4/l8gLn1GWjhw1jiwG++h8gKnoKCmu2ij8N6pWO4I8IKD4Pt2AyEQ1PATR6Uf2kkSPhW77HqwvgOAAd7tqn06YPFJEB6WPsAwcHhIDwOfjtiFl0ojBn/8BvG/z0P4v392GKDzI/ng30rTKMI1t3sViLC0LAgPvwj+2f/Av10jLT0/8CuEG/7uVQHJVm3M2yNtHZLWF8KMazyqTM1Fh9Sm1f8D7DZpyb3DDv7Rm+ADh4HpDZ41Zs92aRpJpYZwxTywMC2QkdOq6javM0u5IRVlYFlngCUke/Y8pxo4DEjLAo4dlr54eRB8+go/mAfx9YVSPw4dBTbvbgpo2kAFELqLTkZqACmoAQAc+AXcx8vWPeWyPUIn009OTKGQ9kjy8fBpT8NiE8AGnUkBTQhiggLCjXdLq/cKC8A/Xd7usdxuk2oHcRFs1HiwXO/rIzG1BsKsG6XNV2Pim6tIPwRx1TtSUq2XuKVeaqOtSdpq5PkFcLzwMLgz2bajcyvKIL7wMPjHb0sfxLkjICx6Q9octr4W/MP/etaWJivEj98GALApl3aYtMsi9GA5gyCMntT1gAbNU+TTZ0nt2Lzu5Mh5gPDDByC++iTQ1CT14833ebxC8XRBQU130VmiMAD0yZRqblgbgUO/B6Zd7akyntweIbnzIXhCegpmiIVw/d8BQBqlaN7y41T8y0+kFSsRerBZvikkyvrlQnj8VSmfh3Pwrz4FX/ex19fjnyyXqjonJIONv0gaafnjN4jP3g/HK0+CH/uz9TmcQ/zhG4iP3yntf6YJA7v2dgh3PCIl6M+9ExAEadXYLz+535avVkvTSTFxYBde5vVr8trgs6X8wMYGudBlIPCjhyC+8oT0vj5gCIRb/4+m5ztAQU130UmiMNC8XHfQcABSMllQOZOEk1K9riZLSHfFhpwFNukvAADx7ZfBT9nIkxcXnqwvdNXNPt2zjWl1EK6/C+za26XnWvuhtPTXQ/xgHvj3GwAAwnV/g3D1XyEs+jfY2PMBQZBW4i28G45/PSOXYuA11RBfXwS+/FXA2gBknQHhsVcgnDtFHllkaX3Bzp8BABDf+xd4yxpc7bWl0gi+YZV0/uU3BLQukhMTBLCLmkdrvl0jVdH1M15YAPGlx6QieTkDIdz+sJQoTtpFQU03wd0ZqQHABktTUHzfbn83qUMdbY9AyOmAXTZXyierM0N86yWpOCCkPBNx+auAww4MPkuqRuwHwrlTwEZNALgI8c3nT76HuIE3WSGueFV6HedOkfNoWGwChLl3QHhyKdjI86T6J3t+hPjEnXD86xmIj/9N2hRWqZSqiN+3CCw+qdX12cVXAQnJgKlKGg3qrD2fvCNNveQMlPbfChJ25jlAUi+pTtCWL/36XPxEobQRr6VOWu12xyNBCea6GwpquovmOVwW3sk3ugFDpSHishNS4a5gcXM5NyE9FVOpIdx8n7TVwYFfpekTAHzzeqnyd5gWwtW3+jU3il19ixQ8VFVAXPGa22Xp+doPgfISqWrzZde3vm5iCoSb/gHhsVeB4aOlelR7fpSqgadmQFjwIoQpl7a7YoqpNRCuu0N6ru83gB/Ma78t+XnSTvdMgHDl/KDmkjFBATb1CqldX38mbw/ia7y0SNqAt84sbWdy52M+Xc3Wk1FQ0124O1Kj1QHNdS74b8GbgupsewRCTgcsORXsqpsBAPzz/0H8eSv4pyukxy67HszPtT9YmE4KrBRKYM+P4N9/1ek5/Nif4F9LAZhw9a0dVkdmvfpAcev/QXjkJbCR54FdPAfCgufdWhzA+g0Ca97WQ1zxKnhT6wCBiw6IH0gJxWzcBWB9Mju9rr+xs8+VKlfX1oBv7bw/PcVLiiC+8Ii0ZUFqOoS7n/CqQvXpioKa7sKN1U9OzhLxfPN6cLvdn61qk8v2CL3TA/78hIQSNmayNMXkcID/55/Sfk45AwNWS4qlZYFdKlUZ5x+9KW1q2A5ut0Nc/gogilIdlKEj3XuOPn2lkZu/zPYoh45dNlfaZLS8BHzNB63bs/UboOgIoAsHm3GN29f1J6ZUgk2VEpX5V5/6dKUpP7gP4rP3ScnZyb2lTX1DZPuB7oKCmm6Aiw5pJRHQ6UgNACmRLzIKKC8G377Rz61rQ8vtEfQdbI9AyGmAMQZ2za1ShVsAUKogXPs3aa+qQLVh8iVSrRVbE8T//rPNUREA0gjN8SNAeCTY7Pn+b5cuHMI1tzY/92fgzuq/kAqO8s/elY67eI5Pk6m7ip0zSdqOwFTls/dYcftGKSnYUi/l0Nz3dNCK/HVnFNR0B5Z6KUgApM3EOsHCdGAXNc/7rv2g3Tcwf5G3R6AkYUIAAEwXAeGWB6Ry9nNuAUvqFdjnFwQI8/4O6A3SBogfv9XqGF5adHL7jStv8rwwnrdtG3K2NJLFRYjvvCqPLvO1H0g5Osm9wc6bGpC2uIupVGBTLgUAaePLLoyIc84hfv4e+Nsvy5WChX8spIDGSxTUdAfOqacwrdsFl9h5U6UiXKYqKTExkJwrnyhJmBAZy8iG4vFXIYy7IDjPr4+GMO9uAADf8iX4nh/lx7goQlz+mlQkb+AwsFHjA9u22fOlqfWiI9KUTnEh+GZpfydh9vyQLDTHxjWPiFeWg+/8zqtrcFsT+Jsvgn/xkXTNi64Au+kftGy7Cyio6Q7cqFFzKqZSScsm0fxNwo1aEL7Ci6Sgxt3tEQghgcEGDgNr3tFdXP4qeJURAMC/2wAc3g9owiBce3vAVxgxvQFstlSAkH/xEcS3lgCiKG0HcMbQgLbFXUytkfuSr1/lceVmXmuG+OKjUkCkUIDNvQPCzGsDOi3ZE1HvdQceJAm3xEZNAJJ7SyXJm1cz+BvnHCiSCnHRSA0hoYfNuEbax8hSB/HNF8CNpXKtGDbzug63H/Bru0aOBwadKY0WHTss5R7NmheUtriLnXeh9L5cdgJ81za3z+NlxVJC8OH9gDYcwl2PQxh7vh9bevqgoKYbcLfw3qmYQgFhhrSLM/92Dbi52tdNa03eHkFJ2yMQEoKYUgXh5nsBjRY4tB/iM/dJ1X/79gebELzcFcaYlDSs0Uq3L5jRZuG+UMLCdGCTpcrRfP3HcoHFjvD836U+Ly8BYhMg/N9isAFD/N3U0wYFNd2BXHjPi6V9w84B0rMBa2OX9oBxmzNJOJm2RyAkVLGEFGlFFgDU1gBKJYS5d7RbLC9g7YpNkPY2uvAysGmzgtoWd7GJ0wGtTtrH69edLo9xmw38+BGIO7ZA/HQ5HK8thPjSI1JKQUYOhIf+CZbSJ0gt75lCL/uKtFZvlv72cKQGaP72c+l1EF98BPy7DeDnXwIWl+jjBp7EKUmYkG5BGDUe4h+/gm/bKC2ZTu4d7CYBaM77GTgs2M1wG9NFgE2YDr5+JcTP3wM7fgS8+BhwolCq19XW6M2ZoyHMuxtMTdse+BoFNd2Blzk1TmzAEGDAEKlU+5r3wZpXQPiFvD0CJQkTEurYdXdIS5OTaKq4K9jki8G//VxaLt+8uadMFw6kpIH16iMt6e+dKU31BXG7h56MgpruwIvVT6cSZl4H8cA/wHdsAZ9ymfQfzA9Obo+Q7pfrE0J8hwmCtJiAdAmL1INddTP4tm/BElKAXn3AUtKAXmnS/lkUwAQMBTXdAO/iSA0g1cjA8HOkHXU/+x8Utz/ko9adRNsjEEJOV8LY8wFawRR0lCjcHTSP1DAvcmpaEmZcAzAB+GUH+J9/+KJlrmh7BEIIIUFEQU134IPpJwBgyb3BRk8AAIir35VqyviQM0mYtkcghBASDBTUdAfy9FPXRmoAgP1lDqBUAgf3Aft/6fL1XMj5NBTUEEIICTwKakIcF0XA0hzURHR9C3oWGw82/iIAzaM1bhSLctfJ7RHSfXZNQgghxF0U1IS6BotHO3S7g110hVS189hhYM92n1zTZXsEShImhBASBBTUhDpnPo1G67MKvSwyCuyCSwAA4ufv+2a0puX2CFTzghBCSBBQUBPqfJhP0xI7f4ZUFKq0yDejNbQ9AiGEkCCjoCbUdWGLhI4wrQ5skrQRm7huZZdXQtH2CIQQQoKNgpoQ54vCe+1hk/4i5dYUHQV++7lrF6PtEQghhAQZBTWhTi6854egJjwSbELzSqgujtbI2yNQkjAhhJAgoaAm1PlxpAYA2PmXAGo1cCQfOPCLV9fg1saT2yPQ9BMhhJAgoaAm1MnVhH2bU+PE9AawcVMAAOIXH3l3keJCadm53kDbIxBCCAkarza03LBhA9auXQuTyYS0tDTMmzcPWVlZ7R5fX1+PDz74ADt37kRdXR3i4+Mxd+5cDB8+HACwevVq7Ny5EydOnIBarUZOTg6uueYapKSkyNd4/PHHsX//fpfrTp48GTfffLM3L6H78PNIDQCwKZeCf/clcGg/eH4eWM4gj86Xt0egURpCCCFB5HFQs337dqxYsQLz589HdnY21q1bh0WLFmHJkiWIiopqdbzdbsfChQuh1+txzz33ICYmBhUVFdDpdPIx+/fvx5QpU9C3b184HA588MEHWLhwIV588UWEhYXJx02aNAlXXnmlfFutVnva/G6H+3mkBgBYdCzYmMng322AuG4lFB4GNbQ9AiGEkFDg8fTTF198gUmTJmHChAlITU3F/PnzoVarsXnz5jaP37RpE+rq6nDfffehf//+SEhIwBlnnIH09HT5mAULFmD8+PHo3bs30tPTcfvtt6OiogIFBQUu19JoNDAYDPKfloFRj+XHROGW2IWXAYIA7P8FvOCg2+dxUTx5PI3UEEIICSKPRmrsdjsKCgowY8YM+T5BEJCbm4v8/Pw2z9m9ezeys7OxbNky7Nq1C3q9HmPGjMGMGTMgCG3HVBaLBQAQEeE6OrF161Zs3boVBoMBZ555Ji677DJoNJo2r2Gz2WCz2eTbjDFotVr5Z19yXs/X1wUgTz+xCL1/rt+MxSeBj5oAvn0j+PqPIdzxSKfncM7B339D2m5BECBkn+HXNspt9Wd/k1aovwOL+juwqL8Dy9/97VFQYzabIYoiDAaDy/0GgwHFxcVtnlNWVgaj0YixY8fiwQcfRGlpKd588004HA5cccUVrY4XRRHvvPMO+vXrhz59+sj3jx07FnFxcYiJicGxY8fw3nvvobi4GPfee2+bz7t69WqsWrVKvp2RkYHFixcjPj7ek5fskaSkJJ9f80RDPUQA8ekZUCUn+/z6Ldmuvw2lOzaD/7oTsRYz1H37tXss5xym/76Iuu++BBhDzD+eRPjgYX5t36n80d+kfdTfgUX9HVjU34Hlr/72KlHYE5xz6PV63HLLLRAEAZmZmaiqqsKaNWvaDGqWLVuG48eP48knn3S5f/LkyfLPffr0QXR0NJ588kmUlpa22TkzZ87E9OnT5dvOqNBoNMJut/vq5cnXTkpKQmlpaZcr87bERRFirVRR2GhpBCsp8dm12ySowUaMBd/5PcqXL4Xi1v9ru12cQ/xkOfiGT6TT5t4Jc78hMPu7fc381d+kbdTfgUX9HVjU34HlTX8rlUq3ByQ8Cmr0ej0EQYDJZHK532QytRq9cTIYDFAqlS5TTb169YLJZILdbodSebIJy5Ytw549e/DEE08gNja2w7Y4V1u1F9SoVCqoVG3vQeSvX1zOuW+DmgYLwKXNJrku/ORu3X7ELroCfOf34Hu2QzxxDCylT6tjxDXvywENu/pWsDGTgvJm4Ov+Jh2j/g4s6u/Aov4OLH/1t0eJwkqlEpmZmcjLy5PvE0UReXl5yMnJafOcfv36obS0FGKLnaBLSkoQHR0tBzSccyxbtgw7d+7Eo48+ioSEhE7bcvToUQBAdHQProviXPmk1oCpArPSi/VKA4aNAjgH/3JVq8fF9R+Dr/1QOvbKGyGMnxqQdhFCCCGd8Xj10/Tp07Fx40Zs2bIFRUVFePPNN2G1WjF+/HgAwGuvvYb3339fPv6CCy5AXV0d3nnnHRQXF2PPnj1YvXo1pkyZIh+zbNkybN26FXfddRe0Wi1MJhNMJhOampoASKMxq1atQkFBAcrLy7Fr1y68/vrrGDBgANLS0rrYBSFMXs7t35VPpxKmzQIA8J++By8/OaUkfv0Z+Op3AQDs0rkQJl8S0HYRQgghHfE4p2b06NEwm81YuXIlTCYT0tPT8dBDD8nTTxUVFS5ZzXFxcViwYAGWL1+O++67DzExMZg6darLCqqvv/4agFRgr6XbbrsN48ePh1KpxL59+7B+/XpYrVbExsZi5MiRuPTSSz1/xd1JAArvtYWlZQGDzgTydoNv+ATsur9B3LwO/OO3pMcvngNh6mUBbRMhhBDSGcZPs0lEo9HostTbFxhjSE5ORklJiU/nCMWd34P/93mgXy4U9y7y2XXdwQ8fgLj4AUChBJs+C/xzafSNTb0cbOa1QV3+6K/+Jm2j/g4s6u/Aov4OLG/6W6VSuZ0oTHs/hbIgjdQAAMsaAPQfDDjsJwOayZcEPaAhhBBC2kNBTSiTqwn7b4uEjjhzawCAjZ8KNmseBTSEEEJClt/r1JAuCFKisKxfLtjMawHOpWknCmgIIYSEMApqQlkANrPsCGMM7KLWBRIJIYSQUETTTyGMBzGnhhBCCOluKKgJZQHaoZsQQgjpCSioCWU0UkMIIYS4jYKaUBbknBpCCCGkO6GgJkRxzgELjdQQQggh7qKgJlQ1NgAOh/QzjdQQQgghnaKgJlTJO3SrwdSa4LaFEEII6QYoqAlVziRhHU09EUIIIe6goCZUUZIwIYQQ4hEKakIUFd4jhBBCPENBTaiqN0t/00gNIYQQ4hYKakJV80gNVRMmhBBC3ENBTagK9g7dhBBCSDdDQU2oopwaQgghxCMU1IQoTqufCCGEEI9QUBOqKKeGEEII8QgFNaGKRmoIIYQQj1BQE6ooUZgQQgjxCAU1IYhzTonChBBCiIcoqAlF1kbAYZd+pqCGEEIIcQsFNaHIOUqjVAFqdXDbQgghhHQTFNSEohb5NIyx4LaFEEII6SYoqAlFtPKJEEII8RgFNaGIghpCCCHEYxTUhCAur3zSB7chhBBCSDdCQU0oah6pYTRSQwghhLiNgppQRDVqCCGEEI9RUBOKKKeGEEII8RgFNSGI0xYJhBBCiMcoqAlFlFNDCCGEeIyCmlBEOTWEEEKIxyioCUUU1BBCCCEeU3pz0oYNG7B27VqYTCakpaVh3rx5yMrKavf4+vp6fPDBB9i5cyfq6uoQHx+PuXPnYvjw4W5fs6mpCStWrMD27dths9kwZMgQ3HTTTTAYDN68hJAl7dBNOTWEEEKIpzweqdm+fTtWrFiByy+/HIsXL0ZaWhoWLVqEmpqaNo+32+1YuHAhjEYj7rnnHixZsgS33HILYmJiPLrm8uXLsXv3btxzzz144oknUF1djRdeeMGLlxzimqyA3Sb9TDk1hBBCiNs8Dmq++OILTJo0CRMmTEBqairmz58PtVqNzZs3t3n8pk2bUFdXh/vuuw/9+/dHQkICzjjjDKSnp7t9TYvFgk2bNmHu3LkYNGgQMjMzcdttt+HgwYPIz8/37pWHKucojUIJaMKC2xZCCCGkG/Fo+slut6OgoAAzZsyQ7xMEAbm5ue0GF7t370Z2djaWLVuGXbt2Qa/XY8yYMZgxYwYEQXDrmgUFBXA4HMjNzZWP6dWrF+Li4pCfn4+cnJxWz2uz2WCz2eTbjDFotVr5Z19yXs8n17XUS3+HR0AQKOWpLT7tb9Ip6u/Aov4OLOrvwPJ3f3sU1JjNZoii2CqPxWAwoLi4uM1zysrKYDQaMXbsWDz44IMoLS3Fm2++CYfDgSuuuMKta5pMJiiVSoSHh7scExUVBZPJ1Obzrl69GqtWrZJvZ2RkYPHixYiPj/fkJXskKSmpy9doLD8BIwClIQbJycldb1QP5ov+Ju6j/g4s6u/Aov4OLH/1t1eJwp7gnEOv1+OWW26BIAjIzMxEVVUV1qxZgyuuuMJvzztz5kxMnz5dvu2MCo1GI+x2u0+fizGGpKQklJaWSom+XSAePwoAsGvCUFJS4oPW9Ty+7G/SOervwKL+Dizq78Dypr+VSqXbAxIeBTV6vR6CILQaHTGZTO2uQjIYDFAqlS5TKb169YLJZILdbnfrmgaDAXa7HfX19S6jNTU1Ne0+r0qlgkqlavMxf/3ics67fG1e15xTo4ug/2Cd8EV/E/dRfwcW9XdgUX8Hlr/626OkDaVSiczMTOTl5cn3iaKIvLy8NvNaAKBfv34oLS2FKIryfSUlJYiOjoZSqXTrmpmZmVAoFNi3b598THFxMSoqKtp93m5LriZMy7kJIYQQT3iciTp9+nRs3LgRW7ZsQVFREd58801YrVaMHz8eAPDaa6/h/fffl4+/4IILUFdXh3feeQfFxcXYs2cPVq9ejSlTprh9TZ1Oh4kTJ2LFihXIy8tDQUEBli5dipycnB4b1NBybkIIIcQzHufUjB49GmazGStXroTJZEJ6ejoeeugheRqooqLCJas5Li4OCxYswPLly3HfffchJiYGU6dOdVnt1Nk1AWDu3LlgjOGFF16A3W6Xi+/1OFRNmBBCCPEK46fZJKLRaHRZ6u0LjDEkJyejpKSky3OEjqVPA3t3gF19K4TxU33Uwp7Fl/1NOkf9HVjU34FF/R1Y3vS3SqVyO1GYCqGEGhqpIYQQQrxCQU2okROFKaeGEEII8QQFNaGGNrMkhBBCvEJBTaiRp59opIYQQgjxBAU1IYQ3WQFbk3QjgkZqCCGEEE9QUBNKnKM0CgWg0Qa3LYQQQkg3Q0FNKKk/uUUC7RhLCCGEeIaCmlBCy7kJIYQQr1FQE0rqzdLflCRMCCGEeIyCmhDCaaSGEEII8RoFNaGEdugmhBBCvEZBTSihkRpCCCHEaxTUhBK5mjDl1BBCCCGeoqAmhFBODSGEEOI9CmpCCY3UEEIIIV6joCaUUKIwIYQQ4jUKakKJpV76W0cjNYQQQoinKKgJJdZG6e8w2veJEEII8RQFNaHE2iD9rQkLbjsIIYSQboiCmhDB7TbAbpduhFFQQwghhHiKgppQYbWe/FlNQQ0hhBDiKQpqQoVz6kmpBFMqg9sWQgghpBuioCZUOJOENZQkTAghhHiDgppQ0egMamjqiRBCCPEGBTWhglY+EUIIIV1CQU2ooBo1hBBCSJdQUBMieCON1BBCCCFdQUFNqLBSTg0hhBDSFRTUhIomKahhtPqJEEII8QoFNaHCufqJqgkTQgghXqGgJlTQ9BMhhBDSJRTUhAp5STdNPxFCCCHeoKAmVND0EyGEENIlFNSECO6cfqLNLAkhhBCvUFATKqiiMCGEENIlFNSEiuaRGkbTT4QQQohXKKgJFY20SzchhBDSFUpvTtqwYQPWrl0Lk8mEtLQ0zJs3D1lZWW0eu2XLFixdutTlPpVKhffee0++PWvWrDbPveaaa3DxxRcDAG6//XYYjUaXx+fMmYMZM2Z48xJCD00/EUIIIV3icVCzfft2rFixAvPnz0d2djbWrVuHRYsWYcmSJYiKimrzHK1Wi5dffrnda/7nP/9xub137178+9//xsiRI13unzVrFiZPnizfDutJUzVWWv1ECCGEdIXHQc0XX3yBSZMmYcKECQCA+fPnY8+ePdi8eXO7oyaMMRgMhnaveepjP//8MwYOHIjExESX+7VabYfXaclms8Fms7m0QavVyj/7kvN6XbqunFOj83n7ehqf9DdxG/V3YFF/Bxb1d2D5u789CmrsdjsKCgpcghdBEJCbm4v8/Px2z2tsbMRtt90GzjkyMjJw1VVXoXfv3m0eazKZsHfvXtx+++2tHvvss8/wySefIC4uDmPHjsW0adOgUCjavM7q1auxatUq+XZGRgYWL16M+Ph4N1+t55KSkrw6j4siipqsAIDEPmlQGGJ82awey9v+Jt6h/g4s6u/Aov4OLH/1t0dBjdlshiiKrUZLDAYDiouL2zwnJSUFt956K9LS0mCxWLBmzRo8/PDDePHFFxEbG9vq+O+++w5hYWE4++yzXe6fOnUqMjIyEBERgYMHD+KDDz5AdXU15s6d2+bzzpw5E9OnT5dvO6NCo9EIu93uycvuFGMMSUlJKC0tBefc4/O5tRFoPq/MVAPWYPVp+3qarvY38Qz1d2BRfwcW9XdgedPfSqXS7QEJrxKFPZGTk4OcnByX23fffTe++eYbzJ49u9Xxmzdvxrhx46BWq13ubxmgpKWlQalU4r///S/mzJkDlUrV6joqlarN+wH47ReXc+5dUNNokX5gDFyllgMc0jFv+5t4h/o7sKi/A4v6O7D81d8eLenW6/UQBAEmk8nlfpPJ5Haui1KpREZGBkpLS1s9duDAARQXF2PixImdXic7OxsOh6PViqhuqfHkZpY0r0sIIYR4x6OgRqlUIjMzE3l5efJ9oigiLy/PZTSmI6IoorCwENHR0a0e27RpEzIzM5Gent7pdY4ePQrGGPR6vdvtD1m0QzchhBDSZR5PP02fPh2vv/46MjMzkZWVhfXr18NqtWL8+PEAgNdeew0xMTGYM2cOAGDVqlXIzs5GUlIS6uvrsWbNGhiNRkyaNMnluhaLBTt27MC1117b6jnz8/Nx6NAhDBw4EFqtFvn5+Vi+fDnGjRuHiIgIL152iKEaNYQQQkiXeRzUjB49GmazGStXroTJZEJ6ejoeeughefqpoqLCZQqlrq4Ob7zxBkwmE8LDw5GZmYmFCxciNTXV5brbt28H5xxjx45t3UilEtu3b8fHH38Mm82GhIQETJs2zSXPpltrpJEaQgghpKsYP80yo4xGo0v9Gl9gjCE5ORklJSXeJQrv3g7x388CWWdA8cCzPm1bT9TV/iaeof4OLOrvwKL+Dixv+lulUrm9+on2fgoB3Dn9RNWECSGEEK9RUBMKKFGYEEII6TIKakJBc04Nox26CSGEEK9RUBMKaPUTIYQQ0mUU1IQC2qGbEEII6TIKakKBnFND00+EEEKItyioCQWUKEwIIYR0GQU1IYBTUEMIIYR0GQU1oaCREoUJIYSQrqKgJhRYaUk3IYQQ0lUU1IQCWv1ECCGEdBkFNaGA6tQQQgghXUZBTShopCXdhBBCSFdRUBMKaPUTIYQQ0mUU1AQZt9sAh126QTk1hBBCiNcoqAk25ygNAKgpqCGEEEK8RUFNsDnzaZQqMKUyuG0hhBBCujEKaoKtiZZzE0IIIb5AQU2w0conQgghxCcoqAk2qlFDCCGE+AQFNcFGy7kJIYQQn6CgJsg4bWZJCCGE+AQFNcFGIzWEEEKIT1BQE2y0QzchhBDiExTUBJszUZiWdBNCCCFdQkFNsDXS9BMhhBDiCxTUBJuV6tQQQgghvkBBTbDR9BMhhBDiExTUBBmn1U+EEEKIT1BQE2y0TQIhhBDiExTUBFuTc0k3jdQQQgghXUFBTbA10i7dhBBCiC9QUBNszkRhNQU1hBBCSFdQUBNsVhqpIYQQQnyBgppgozo1hBBCiE9QUBNEXBRpQ0tCCCHER5TenLRhwwasXbsWJpMJaWlpmDdvHrKysto8dsuWLVi6dKnLfSqVCu+99558+/XXX8d3333ncsyQIUOwYMEC+XZdXR3eeust7N69G4wxjBw5EjfccAPCuvO0TZP15M80UkMIIYR0icdBzfbt27FixQrMnz8f2dnZWLduHRYtWoQlS5YgKiqqzXO0Wi1efvnlDq87dOhQ3HbbbScbpnRt2iuvvILq6mo8/PDDcDgcWLp0Kd544w3cddddnr6E0OEcpWEMUKuD2xZCCCGkm/N4+umLL77ApEmTMGHCBKSmpmL+/PlQq9XYvHlzu+cwxmAwGFz+nEqpVLo8HhERIT9WVFSEX375BX/961+RnZ2N/v37Y968edi+fTuqqqo8fQmhw7nySRMGxlhw20IIIYR0cx6N1NjtdhQUFGDGjBnyfYIgIDc3F/n5+e2e19jYiNtuuw2cc2RkZOCqq65C7969XY7Zv38/brrpJoSHh2PQoEGYPXs2IiMjAQD5+fkIDw9H37595eNzc3PBGMPhw4dx9tlnt3pOm80Gm80m32aMQavVyj/7kvN6Hl/X2jz9pNFSUOMBr/ubeIX6O7CovwOL+juw/N3fHgU1ZrMZoii2GmkxGAwoLi5u85yUlBTceuutSEtLg8ViwZo1a/Dwww/jxRdfRGxsLABp6mnkyJFISEhAaWkpPvjgAzz99NNYtGgRBEGAyWSCXq93ua5CoUBERARMJlObz7t69WqsWrVKvp2RkYHFixcjPj7ek5fskaSkJI+Ot1aVoRyAMjwCycnJ/mlUD+Zpf5Ouof4OLOrvwKL+Dix/9bdXicKeyMnJQU5Ojsvtu+++G9988w1mz54NABgzZoz8eJ8+fZCWloY77rgDv//+O3Jzc7163pkzZ2L69OnybWdUaDQaYbfbvbpmexhjSEpKQmlpKTjnbp8nFhcBAOxKJUpKSnzapp7M2/4m3qH+Dizq78Ci/g4sb/pbqVS6PSDhUVCj1+vlkZOWTCZTm3ky7TUuIyMDpaWl7R6TmJiIyMhIlJaWIjc3FwaDAWaz2eUYh8OBurq6dp9XpVJBpVK1+Zi/fnE5555du/Hkcm76z+Q5j/ubdAn1d2BRfwcW9Xdg+au/PUoUViqVyMzMRF5ennyfKIrIy8tzGY3piCiKKCwsRHR0dLvHVFZWoq6uTj4mJycH9fX1KCgokI/Jy8sD57zdpeTdAZcThWk5NyGEENJVHk8/TZ8+Ha+//joyMzORlZWF9evXw2q1Yvz48QCA1157DTExMZgzZw4AYNWqVcjOzkZSUhLq6+uxZs0aGI1GTJo0CYCURPzxxx9j5MiRMBgMKCsrw//+9z8kJSVhyJAhAIDU1FQMHToUb7zxBubPnw+73Y633noLo0ePRkxMjI+6Igjkwnua4LaDEEII6QE8DmpGjx4Ns9mMlStXwmQyIT09HQ899JA8DVRRUeGS1VxXV4c33ngDJpMJ4eHhyMzMxMKFC5GamgpAWj1VWFiI7777DvX19YiJicHgwYNx5ZVXukwf3XnnnVi2bBmefPJJufjevHnzuvjyg6x5+onRSA0hhBDSZYyfZpOIRqPRZam3LzDGkJycjJKSEs8ShT/7H/i6lWATpkGYc4tP29STedvfxDvU34FF/R1Y1N+B5U1/q1QqtxOFae+nYDrNdui2i/SGQQghxH8oqAmm02iH7k9/r8SsDw/i3ztLUWd1BLs5hBBCeiAKaoKp8eQ2CT3dliNmODjw5SETbl1bgG//NEGkoV5CCCE+REFNEHHryTo1PZm50Y5jNdKWEKl6NcxWB17dUYr/+7oQBVWNQW4dIYSQnoKCmmCSc2p69vTT7+XSiFTvKDVenpaBG4bHI0wp4GBFA/6x4Sje+LkUdU00JUUIIaRrKKgJpubpJ9bDR2ryyi0AgEEJOigFhhkDYrH0LxkYlxYJkQPr8024bU0BNtKUFCGEkC6goCaYTpNE4d+dQU2iTr4vVqfCvWN74alJvZGqV6PG6sArO0rx4NeFKKtrClZTCSGEdGMU1ATTabCku9bqwNFqKZ9mUIKu1eODk8Kx5KIMzB0WjzAlwx8VDXhtR/v7ghFCCCHtoaAmmE6DROH95RZwSAnCBm3bBaxVCoZLz4jFi1MzoGDAb2UWHKpsCGxDCSGkCxwiR02jPdjNOO1RUBNMzqBG3XODmn3NU08D2xilOVUvvRrj0vUAgE/3V/m1XYSQ0FTdYJenrLsLm0PEo5uO44ZPDyO/gr6QBRMFNUHC7TbA0RzV9+Dpp9/LWufTdOTSM2IBAD8W1qLY7H1uzZYjNdh2zOz1+YSQ4PjnDyfw0DeF2HWiLthNcQvnHEt3liGvzAIHB1YfoC9kwURBTbBYW9Rn6aEjNXVNDhxx5tO4GdSkGTQYkRIODuAzL98c9pXV46XtJfjnD8Uw1vt2ny9CiP+YGu1yCYi1f3SP4OCzA1XYVFADoXkf5x3Ha+l9J4goqAmW5h26oVSBKT3eLL1TpbVNcAR5ryVnPk1KpBox7eTTtOXSgdJozcaCGlQ1eDZH7RA53txVDgDgAH48XuvR+W1dr6S2iTa6IyQAfimpP/lzqQUnujBaGwg/F9Vh+V4jAODGMxOQm6iDyIEv86uD3LLTFwU1wWJtnnf1w9TTB78ZccuaAvzvV6PPr+0J5zeuQYmeLVk/I16L/nFa2EXu8be1rw+bcNRklW9vO9a1oGb53nL8dU0BXtxegka72KVrERJq6qwObCqoQWltaAQPu4uloKZ50ANfHgrd4OCYyYrntxWDA5iSZcC0nGj8pV80AOl9yErvF0FBQU2w+KlGzfdHzfhwXyUAYN3BatQGcfPIfWXuJwm3xBjDpQNjAAAbDplQ72a14TqrA+/9VgEAuLx5tOePigavh4KbHCK+LagBIPXrfRuOoshs7eQsQroHq13E45uP4+UfS3DLmgLcu+EoPj9QhUpLcKZOHCLH3uaRmsua//9u+rMmJL9M1DTasXBLERrtIgYl6nDzWYlgjGFErwgkhKtQ2yTiu6OU0xcMFNQEix82s8yvaMArP5YAAFQCg9XB8dVhk8+u74n6JgeOVEuBm7v5NC2d1SsCvaPUsNhEfHXI5NY57++rQK3VgbQoDeYMjsOAeClg9HYKateJOtQ3iYgKUyA6TIHCmib848tj2FZIb1b+8ktJPf7v62N4Z085/qxqpGk/P+Gc49UdJThU2Qi1gkFgwKHKRry1pxw3rv4TD31zDF/mVwd0ifKfVY2otTqgUwmYnRuLpAgV6m0ivg+x4MDm4Hj2+xMor7chKUKFB8b1grI5oUYhMEzrZwAAfPFHNf3+BgEFNcHi4xo1FRYbnv6uCDaR46xeEfjr2YkApNEamyPw/7EOGBsgciApQoU4ncrj8wXGMHOANFqz5o8qNDk6/rZ2zGSV57FvGpEAhcAwpk8kAO+noDYfkd5MJ2VG4aWLMjAwQYtGu4jnthbjrd1lsAc5Z6kn+t+vRhwwNmD1gSrc8+VR3La2AO/9akRhDY2Q+dLKvEpsPVYLBQMenZCKt2Zm4eYRiRgQrwWHNHX875/LcP2nh/HYpuP49k//T6fsaZ56GpKkg0oh4MJsAwBgfX7oBAecc/z751LsNzZApxLw8PhU6DUKl2Mm9zVAo2A4VmOVR6tJ4FBQEyTch5tZNtpFPP1dEaobpVGKe8Yk47z0KERrlahqsOOHICxtzvNwKXdbzk2PQqxOiepGB7Ycaf81cM7x5u4yiBw4p3cEBieFAwBGNwc1f1Q0oMLDIXVzox27m5eUTsiQ+vKpSX3kQOvzP6rxyLeFQRuq74lKaptwqLIRAgPO6R0JtYKhuNaGlXmVuOOLI7hz3RF8nFeBkhDJ/+iuthea8X7zNO1fz05CbmI4orVKTOsXjWcvSMObM/ri+mHx6BsTBpFLo2ev7ijFg98UwuzHkZvdxdL/t+EpEQCASX0NUCsYjlRbcbCisaNTA2bNH9X49k9ppdN9Y1PQO0rT6pgItQITM6MAAF8cDN2coJ6Kgppgsfpm+knkHC//WII/q6zQaxRYML4XdCoFVAqG6TlS0trnf1QF/JtOy00svaVSMFzSXwoiVu+vbHc1146iOvxWaoFKYLhheIJ8f6xOdXIKqtCz0Zqtx2rh4EDfGA36GKQ3LoXAcP3wBPzfub2gUwnYb2zAPV8elQM40jXOEbXBiTr837m9sPyyLNwzOhln9YqAUpBG4/73awX+2pz/Qf3uuT+rGvHSdmmK+i/9onFBlqHVMfHhKsw8IxYvTk3Hv/6SiasHxyFSo8CfVY14yE+BvNnqwKFKKXAZniJ9KdFrFBibJhXjDIXVRLtO1OGdvdLKyhuGJ8jBV1umNScM7yyq83gvO1OjHf/eWYr93awAYaigoCZYmpd0d3WH7g/3VWB7YS2UAvDgub2QGKGWH5uSLQ2DHqm24rcAfgBYbA78WeV9Pk1LF2QZEKEWUFxrw09FrQOTJoeIt/dIbzQzz4hxef0ATk5BeRjUbDkiJQiPz4hq9dg5vSPxwoXpSDNoYGp04JGNhfh0f2XIDJF3V1ubRxSdH2Q6lQLnZUTh4fGpWH5pNu4YlYShSTo5/+OJzcexr6y+o0uSFqoa7Fj0XRGaHBzDksNdvgC0J0WvxqzcODxzfh/EaJU4XtOEh77x/aazv5TUgwNIi9K4TFdflGMAAPxQWBvULQgKa6x4/odiiByY3DdKXuXUnt5RGgxNluptrc83uf08dpHjua0n8OUhE5buLKX3FC9QUBMsTV1f/bT1qBkfNa90uvXsJJxxyqhIpEaBSX2lD+XPA1jl8o/mfJrECBXiwz3Pp2lJqxJwUfOI06f7W484fXagCmV1NsTqlPKKiZbOaQ5qDhgb3P6GecLchPzmaZBzmz9gT5WiV+OfU9IwIUMPkQPL9xrxzx+KaRmnl47XWHHUZIVSAEb1jmz1eIRGgcl9DXhiUh+8fWkWzuoVjiYHx8ItRThA32g71eQQ8cx3Rai02JGqV+O+sSlQOKvFuaF3lAbPXtAHiREqlNbZ8ODXhSjyYZ7TyamncJf7s2O1yI4Ng13k+ObPGp89nydMDdJKpwa7iIEJWvz1rCQw1nnfOQOfbw6b0GBz733h3V+McimM4zVNOFwVGtNu3QkFNcHiLL6naT0n645DlQ14ZYc0jDxjQAwm9zW0edzF/WPAINV/OB6gZMs8L5dyt2dav2ioFQyHKhtdEu8q6m1YlScFddcPS0CYsvWvc5xOhf5xUuC43c3RGucozbDk8HY34QQAjVLAXeck49azE6EUpNGgRzYep03tvODM+xqaFI7IUxIvT2UIU+L+cb0wNDkcjXaOJzYX0X47HZBWOpUiv7IREWoBC85LRbi64z5uS2KEGs+c3wepejUqG+x48JtCFPjgQ1fkJ5dynxrUAJC/1Hx1qDrgBUUtNgee3HIcZXXSSqf/G9cLKoV7weDwlHAkR0oruJzvKR3ZXmiWq6in6qUR541dDOR+K60/7VZrUlATLF2oU1NpseHp706gycExIiUc1w2Nb/fY5Eg1zk6V5n7XBKjsuDOfJreLU09OhjAlJjUn3n3SYqPL5XvLYXVwnBGvxbi01t/uncamuT8FxTmX60u0NfV0KsYYLsyOxuMTeyNcLeBgRQPu/+qYT7/F9nScc2xtzqdxbmjaGbVCwEPn9sKgRB0amuut+OIDtida9Xslvj9qhoIBD4zrhRS9uvOT2hGrU+GZ8/ugb4wGZqsDD39biAPGro2UFVRZUdPoQJhSwID41u8ZY/pEIlItoLzeLo/oBILNwbH4+xP4s8qKKI0Cj03oDX2Y+5XRBcYwrTkg++Jgxyu4isxWvPJjKQDpS+r8EdLq1a3HzJ2u/GyPqcGOJzcX4bmtxR7nFHZnFNQEi5cVha12EU9/dwJVDXb0iVLjH24MI89oXrGzucAMk59HERpsIg43J/wNTPBdYcGZZ8RAYNLc+59Vjfi1yITvjprBAMwfkdjhcLAnU1AHjA0oq7NBqxQwMrX9RMBT5SaG47kL0pDUPDx//9fH/JbvwTn3WUEyY70N+8st+LGwFl/mV+PDfRV44+dSPLf1BBZ8cwy3ry3Atavy8eCaPFR7uGWFu45UW3HC3AS1gskBuDs0SgEPn5eKAfFa1DdJuyQfM1Ew2dKPx2vxv1+llU7zRyTKKwO7Qh8mrQQ8I16LepuIxzYed9newFN7mgMVaSl36//HGqWASc0j0V96kJ/SFSLneG1HCX4ptUCjYHhkQqpXweCkvlHQKgUUmZvwa2nbwV+jXcTi70/I01vXDY1HbqIOcTol6ppE/FzkXSC34bAJtuaRraU7S2Hy0//fUENBTZBwL+vUvPurEYerGhGpUWDBeanQqTofRh4QL81L20Tu91UEf1Q0wMGBeJ2yVdJuVyRGqDG2j/QtflVeBZ7fdAgAcH5WFDJjOu5DT6agnEvHz+kTCU0b01kdSY3S4LkpaegXJ33IPr7pODYV+DYPoLDGijvWHcG8Tw93uXbL9kIzbvrsTzz4TSGe3XoC//65DB/8VoH1+SZsK6xFXnkDisxNqGl04NuD5bjji4Iu76XVFufU05kp4W79PrekVQl4dEIqsmPDUGuVkraDMUrWaBexp7gu6PutOTlEjl9K6vHStmIAwLQcA6bmdJzc6olwtQKPT+yNocnhsDo4ntpShJ+8/N3Y0xwQDUtuP+C6MNsA1nxsIJb0v/uLEVuOmiE0j25lx3r3BU2nOpnX2NaWL5xzvL6jFIU1TYjWKnHf2F5QCAwKgWFC80jxRi/eQ2wOjg3N7/XhKgFmq+O0STymoCZYGj2ffmpyiPKH5B2jkpAU6V7QwNjJpdFf5vu3iJYv6tO0Z+YZ0mvYVliLP8pqEa4ScM2Q9qfeWhrTPAXVUVDT5BDlD9gJGe5Ng5wqKkyJhZN7Y2xaJOwi8PKPJXjvV6NP3kycWzUcr2lCvU3EJ835RN7gnOPD36TzY7VK9I/TYmRqBKZkGTBrUCzmj0jAvWNS8NSk3nhqch9kx0fAbHXg2e9PYMn2YtS5uXWFO+2Qp57aScrujE6lwOMTeiMjWoOaRgce3ng84LVsXttRgic2F+GVHSVB+eAQOcfR6kas/aMKC7cU4ZpVh/DYpuOwOjiGJulw45mJPn9OaaSsF87pHQG7yPHs1hMeV/+tszpwsDkf6swOlkgnR6rlfJsNblYY99baP6rwafM0999GJuHMXu6PHrZlWk40GIBdxfUoPmWDzvX5Jnx/TJoavH9sCqJb5PA5a93sLan3eGPf7YVmVDc6EKNV4slJfaAUgJ+K6rz+klVW14R3fzHi+6PmkB/x8f320MQ9zdNPnizpdpbtj9UqMaKDN4C2jO4Tifi9Shgtdnx31NxmfQpf8GdQkxkThmHJ4XJS4ezB8Yhyc457dJ9ILNtdLk9BxbZR5fjnE3Wot4mI0ym71H61QsA/xqQgKaICq36vxMq8SpTW2XDHqCSoFZ5/j7A5ON7ZWy4X8sqKCcPhqkZ8f8yMq4fEIyHC8xVmu4vrcazGCq1SwCvTMxDRQeIoYwzLB2fipa/34ZPfK7H5iBn7yiy485xkDOnidEZ+ZSPK620IU0r75ngrQqPAkxN7Y8G3hSisacIj3xbi6fPTvOobT/1hbJADsy1HzOgTpWlzJZ4vcc5RUmvDb2X1+K3UgrwyC2pO2ectXC1gREoEbh6R6NFKJ0+oFALuG9sLr+4oweYjZry2owSDEnWI6SDBvqVfSushcikxtrN/q4tyorG7uB7f/mnCnMFxHo+kuuOHY2Ys2y2ViLh2SLw87dUVKXo1zkwJx67ieqzLr5bzZf4wNuCtPWUAgOuHJ7RavZqiV2NAvBYHjA3YcqQGl57h/u/U2ub3iqnZBmTFhuGqwfF49xcj3txdjsFJ4R6tSi2ra8KD3xSi0nIymOkTpUZuUjgGJ+owKEGHiE6S+wOJRmqCRa4o7H5Q45waOS9D7/GblEJg+EvzaM3nB6og+uHbpNUu4nBV887cPlr5dKorBsWCAegbFy4XuHJHnE6FfnFSCfj2plDk/k3XQ3BjyWZHBMZw7dB43DEqCQomjbI86sXKqAqLDQu+LZQDmssHxuK5KWkYkqSDyKXCit745HdplGZKtqHDgMZJpRBw7dAEPHN+GpIjVaiw2PHoxuP4766yLo38OUfGzu7l+XTfqZy5Hr30ahgtdjy8sRDldf6t+Mw5l+skOVesvPuLsc2aSr5SUNWIe748ilvXFuBfO8uwrbAWNVYHNAqGYcnhmDssHi9cmI53L8vGPWNS/P6BoxAY7jwnGf3iwmB1cLz/q9Htc51bI5zZxqqnUw1LDkdCuAp1TaJc08iX9pXW46XtJeCQ6uNc1rypri9Mb37v3fhnDSw2B0yNdjy39QTsopQI3V7dG+dozcY/a9weATxY0YBDlY1QCgwXNG81MXNADPrFaWGxiXjlxxK33/+N9TY8svE4Ki12JEaokBEtrdYtrGnCuoPVeOb7E7hm1SHc8+VRvLOnHHuK69xevu4vFNQEi4ern8yNJzP/3VmV05bzs6KgU0lJa843E1/6o6IBdhGI1SmR6KdvyAMTdHhlegbemD1c3kTOXfIqqDb2gmq5LcL4TO/6ty2T+xrw2MTeCFcJOGBswI2r/8Sz3xdh2zFzp8HAr6X1uGf9URysaEC4SsBD5/XCtUPjoRCY/K3t68Mmj0vXHzBasN/YAKUAXNzfszyL/vFaLLkoA1Ob3yy/OFiNu7886tWSapFz/ND8bzE2vf3Va54waJV4alJvJEWoUFZnw82f/4m71x/B23vKsetEHSw23+5a/+PxWvxR0QCNguHJSb0xNdsADuDFbcU4Wu3b1VgOkePjvArc99VRFFRboRQYBiVocdVgqTjee1fk4PGJvXHpGbHIig3z2+hMWwR2spr3xoIat14751zOp+moOq+TQmDy752vE4YPG+vw9HdFsIsc5/SOxE1ndrz4wFNDk3RI1avRYBfxzeEavPBDMSobpJpBfxvVft2bsWnSdiFF5ia54nJnnF+Azk3Xw9A8kq0QGP5+TjI0CobfyixY70ZuZVWDHY9uLERZnQ3JkdKqtyUXZeDdy7LwwLgUTM02IFWvBodUqXr1gSo8sbkID3x1zL1O8RMKaoLFw126tx6rhV0EMqM1SDN4V9tGp1LI007+KMYnTz0l6Hz6hnCqNEMYorSeB02jO1gF5bItQhv7uXTFkKRwPDslDekGDWwix4/H6/DcD8W47pNDeGFbMXYW1cLWYtmmyDlW5VXi8U3HUWN1ICNagxempmNkamSLa+rQN0aDJgfHOg+Tv535AuMzotqchutMmFLAX89OwmMTUhGjVeKEuQkPfH0MK/MqPLrOgfIGVDXYEa4SMLyDJFFPxepUWDi5D7Jjw8ABFFRb8dmBKjy1pQjXfHwID3x1DO/9asRvpfVeL5cFpGnB5XulUYmZZ8QgVqfCTSMSMThJh0a7VBjQV6sNi83SFMD/fq2AXQRGpkZg2cy+WHR+GmbnxuGMhLZXDgXSgHgdRveJlItRduZItRXVDXZoFMztlZKT+0ZBJTAcrmr0WW0iY70Nd676BfU2EWfEa3HPmGSfB4SMMUxvHo1Zvrccv5VZEKYUmrdcaX8kTadSYHRzMUp38mEqLTZsax7Fmn7K6E+KXo3rmwPP5XuNKDK3n1BvarTjkW8LUVxrQ0K4Ck9N6iO/V+jDlBjdR4+/np2E1/+Sibdm9sXdo5MxuW8UEsJVOMOHq169QUFNsHi4+qmjsv2emN4vGgIDfiuz+Lyuhz/zaXyhoykoX/Vve/pEabDkonQsuSgdl50Rg4RwFRrtHN8fNWPRdycw95PDeOXHEuw6UYenvzuBd381QuTSDuGLL0hD8ilJ4YwxXNY8WrPuYLXbS7wLa6zYWVQHBsibc3preEoEXp2WgXPTparK7/1a4VaRMSfnFMLI3pFQeZFr1JH4cBWevzAdb1+ahX+MScH5faOQFKGCg0sjiivzKvHIxuOYs/IQXtpW7BJUumvDoWqU1tkQHabAjAHSv4VSYLh/bC8kR6pgtNjx7PcnvLq2E+cc6/Or8ff1R3CwQtoZ+q5zkvHgub3kb+Gh5Lqh8VAK0iqlvZ0s83aO0gxu3pXbHfowpZz0/+Whrq/kbLSLeHxTIYx1TegTpcGC81K9yntzx/iMKISrBDiaZ37uGJXU5oaYp5rYvHrqezdq1mw4ZIKDA2fEa9G3jVWhU7MNGJqkQ5ODY8n2kjZX65mtDjy68TiKzE2I1UkLHzrKwYnVqTA+Iwp3jErGf2f0xY1ndr79hj9RUBMEXHQATc1Rshu7dLuU7XezOFl74sNV8n5I3uZjtMVqF5HfPDzqr3waX5D3gmoxBeXOtgi+wBhDRnQYrhuWgP9ckonnpqThL/2jEaNVot4mYmNBDZ7aUoSfT9RBJTD8bWQS7jwnud1ck1G9I5EcqUJtk4hvDpvcasPq5lGakb0jkOqDEakIjQL/GJOCK3OlD/V/7Sxza+WRQ+TySrSOCid2VYxWiXPT9fjbqGS8cUlf/OeSTNwxKgnj0/WI0SphEzm2HDVj6c4yj1Yt1Vkd+GifNDI1Z0g8tKqT/0aRGgUePi9VnnL0diltpcWGxzcX4Y2fy2B1cOQm6vDyRRmYmBnl15HQrkiOVGNqtjRC8M6e8g6XuDvr0wxL9ixB3FlheOvR2i7vGr4qrxLHa5qQEKHB4xN7+zX/SKsS5DzAS/pHy3ucdcZZs6a+ScTODmrWNDlEfNW8Mmx6O9PKjDHccU4ywlUCDlU24pP9riso65oceHxTIY6ZrIgOU2DhpD4el+bw9RcUT1FQEwxNLYb93BipcX77HZoU7rLkz1uXNH9D33rU7LMddw9WNMAucsRolUiO9P+KE2+1nIJyLpN0d1sEX2KMoV+cFjedmYhlM/vi6cl9MDXbAL1GgeRIFRZPScP5naxQUwhMLqz4+YEq2DupkWKst+H7o9Jr9WQlhTuuHBSHgQlaNNpFvLCtGDZHx23Z17xaJ1Kj8ElBOHclRqgxua8Bd49JwVsz+2LBeb0gMGlo35Mg/+PfK1HbJKJPlFqudt1SapQG941zXvtk+Xt3cM7x1YFS/O2LAvxSUg+1guGmMxPw5KTeAVnN1VWzcuMQrhJw1GTF5nZG7uqbHDhgdC7l9uzfPyc2DH1jpKncNX94P1pTWtsk/7vcNzkHcV3cp84ds3Pj8Mq0DLc2E3USGJMThjuagvrhmJQwHqtTYlRq+18U4nQq3HyWtALrw98q5BF7i82BJzYdlysoPzm5T5eqTwcLBTXBYG0OahgDVB3/0riW7ffNKEJ2rBZnxGvh4MBrO0rxzWETDlY0dCmJ8vfywOTTdFV8uAr94qRcix8LayFyLq968tfUU2cExjAwUYe/np2EFZdlYelfMtscOm7LxMwoGMIUMFrs2NpJjZA1f1TBLgKDErToF+fbeW+FwHD36BREqKVvgO//1nFOhXPqaXTvSI8Tvn2FMYazUyMxr/kD5p09Ruw60Xn11rK6JjkZ8/phCe3mXwxLDpeH4pfvNXZaGbbSYsOWIzVYtKUID3+xH/VNIrJiwvDS1HT8pX9Ml1fkBYpeo8AVg6Sg+b1fK9qcGv2t1AKRAymRarfrbTkxxnB585L51QcqvU7IfntvOWwix5CkcJyXFefVNTylEBjSDBqP3yNb1qxp64so51wu7ndRTnSnOUHnpetxTu8IODiwZHsJaq0OPLW5CPmVjYhUC3hyUm+f5xYGCgU1wWA9mSTc2S+3s2x/mFJoc/dibzkL2e0pqcdrP5Xi/q+O4aqVhzD/sz+xcMtxrNhbji1HanCkurHTb91Ai00sE4ObJOaOMc2VibcVmnHA2IDyes+3RfAXxphHH15qhYC/9JP+LVe3sYu5U63Vga+bp6h8PUrjFB+uwh2jkgFIycjt5VTYHFzOaRrno1VPXTG9XzSmZEmrlp7/oRiFnWy18O4vRthFjiFJujY3YGxpWk6La28rdtnGwdxox7ZCM/69sxS3rS3AvNV/4qXtJdh5og4KxjBncBwWT0nzyTRhoE3rF42EcBWqGuxY08YoVXu7crvrnN6RGJkaAbsIvPZTqceVnH8trceO43UQWOfbrISC5Eg1zojXQuTAd0daf3k5YGxAQbUVagVzqwYZYwy3np2EqDAFjtVYcdvaAuw3SqssH5/YB+nRnlW6DyUU1ASDB9WEnaMIo/tE+LTY1Fm9InD/uBRc3D8aQ5N08rRWeb0NP5+oxyf7q/DS9hL8ff1RXPfJIbz8YzH2FNe1OcXR5BBxsKI5nyZEk4Rbck5B7S9vkHNMRnuxLUKouDDHAK1SwLEaK3a3s1T/y/xqNNo50g0arz9I3DGqd6S87HbJ9uI2q4/+UlKP+iYR0WEKnNHGBoaBxhjDzWclyptjLvyuqN1cjYMVUqE9BmmUprMPQ+e1cxN1aLSLWLilCMt2l+Hv64/g2k8O47mtxfjykAknzE1S/aWYMMw8IwYrrhuB2YPjgzaK1VVqhYBrmzfa/WR/pcu+YZxzj+rTtIUxhlvOSpRzQ5wjZ+5wiBxv7pKK3l2UE40+Xq4mDTS5Zk1B65o1ztd/XroeejfzgqLClLj97CQAUnJwmFLAYxN7Iyu2+wY0gJcVhTds2IC1a9fCZDIhLS0N8+bNQ1ZWVpvHbtmyBUuXLnW5T6VS4b333gMA2O12fPjhh9i7dy/Ky8uh0+mQm5uLOXPmICbm5OqM22+/HUaj65D2nDlzMGPGDG9eQnC5ufKpySHih0L/TI0wxjCmj14etQCkX+zjJiuO1VhRaLLiWPPP9U0iNhWYsanAjEiNtMRwXHokzojXQSEw5Fc0wiZyGMIU6OXhUHIwOKegDlY04mdnbRofTe0FQ4RagQuzDVh9oAqf/F7ZqjKv1S7Kb3qXnhHj92+lNwxPwP7yBhyrseLlH0vwyIRUl9EnZ8G9MWmeF5H0F6XA8MC4Xrhvw1GU1tnw7NYTeGJiH5dl0pxzvNNcaG9CZud7jrW89v0trt0yDyQtSoPcJB0GJ+owsLkyK2MMyQmRKCkJ3I7U/jAuLRJr/gjDocpGfPBbBW4bKX2AFtY0obLBDrWCYWAXFhXE6lS4fngCXv+pFP/71YiRqRFuTWV9eagahTVNiNQocFVuYKadfGFMWiT+s6sMRc0LG5xTyMZ6mzzyeeoy7s6M7B2JywfG4odjZtw5Ktnn09LB4HFQs337dqxYsQLz589HdnY21q1bh0WLFmHJkiWIimr7g1er1eLll19u87GmpiYcOXIEl112GdLT01FXV4d33nkHzz33HJ599lmXY2fNmoXJkyfLt8M83OE6ZLi5Q7e8LYJOGZAVRXqNAgMTdRjYYrRF5Ly5DLxZqlza6MBXh0346rAJ0VolxvaJRH1zLs6gxNDOp2lpTB+9PLrU1W0RQsFf+kdj7cFq7Dc24A9jA/rHn3xz2lhQgxqrAwnhKrdXXHSFRing3rEp+MeGo9hTUo81f1TJS56tdhE7mnNLxvpx1ZM39BoFFoxPxQNfHcPv5Q144+dS3D7yZGG0HUV12G9sgFrBcPUQzz4M9RoFHpmQimW7yhEfrkJuog65ibqAJaYHA2suyPfQN4X45k8TpvePRp8ojTz1lJuo6/Lo6Pl9o/D9UWnbjtd3luLJib07fA8yN9rx/m/SqrVrhsSFVHn/zuhUCozuE4ktR8zYVFAjByBf5ldD5FJ/ejNtdO3QeHlUrSfw+Dfqiy++wKRJkzBhwgSkpqZi/vz5UKvV2Lx5c7vnMMZgMBhc/jjpdDo88sgjGD16NFJSUpCTk4N58+ahoKAAFRWuxby0Wq3LNbpvUOPeSE3Lsv3B+kYrMIYzEnS45awkvD0zC09M7I3JfaMQrhZQ3WDH2oPV2FQgtTOUl3KfyjkFBfhmW4Rgk2pFSAHLpy2WaTpELq/wmDEgJmC/R30MGjlJ9t1fjDhUKQXyu4vr0GgXEa9ThuS3wj5RGtw7JgUCA775s0beQ8cucqzYK43SXNI/BnFeFC1M1Wvw2MTeuG1kEsal63t0QOM0MEGHUb0jpIJ8zaNczqmnjnbldhdjDLePTIJawfBbqaXTHa3f+60C9U0iMqI1ON8H+zoFmnOl3dajUs0aq12Uc+U8HaXpqTz6X2W321FQUOAy5SMIAnJzc5Gfn9/ueY2NjbjtttvAOUdGRgauuuoq9O7du93jLRYLGGPQ6Vw/JD/77DN88skniIuLw9ixYzFt2jQoFG1H2jabDTbbySxxxhi0Wq38sy85r+fudXlzUMM02nbPabktwsRMQ0iMgCgVDMNSIjAsJQK3ns3xS0kdvj9qxk9FtWCM4azUyIC009P+bktChBpn94rAvnILzs+ODon+7apLz4jFxj9r8FNRHY7XNKGPQYNthWaU1dmg1yhwfpZ3v0fe9veF2dH4tdSC7YW1eGFbMV66KKPFtgh6KITQzGEakRqJ64cl4K095Xh7TzlS9RqU1DWhuNaGqDAFLhsU69ffF1/8foeSucMS8HNRHXYV1+OnojocMEqLCkb08s37RYpeg6uHxOPtPeV4a085zkyJQEwbQeeR6kY5ALj5rCQom+updKf+zk0KR3y4EsZ6O3YW1aPB5kBtk4iEcBXODtD7b1f5u789CmrMZjNEUXQZaQEAg8GA4uLiNs9JSUnBrbfeirS0NFgsFqxZswYPP/wwXnzxRcTGtl6F0dTUhPfeew9jxoxxCWqmTp2KjIwMRERE4ODBg/jggw9QXV2NuXPntvm8q1evxqpVq+TbGRkZWLx4MeLj/TfMlpSU5NZxtRo1TADCDNGIS05u85ite4pgF4F+CREYOSDdZ230pT6pwMVnAY02BzgHtG5sjOhL7vZ3e16+MhFWh4hwdc/4xpycDIz/oxabDxmx4agFj16YhjVfHQcAzB7RB+m9e3Xp+t7091OXxGPOOztRUmvFm7+YsKv5W/rMMzORnBS6eUx/TUpChU2BNftK8Py2Yjlh99ZxWejbp2v96K6u/n6HiuRk4PKiJny0pwhLtpfALgKpBi3O7Jfms+e4OTERO0404EBZLZbvq8FzM3JdHuec47EteyFy4Pz+CZg8pG+ra3SX/r54cCOW/XgUW4saUFEnraa76qw0pPZKCXLLPOOv/vb7u3lOTg5ycnJcbt9999345ptvMHv2bJdj7XY7XnrpJQDATTfd5PLY9OnT5Z/T0tKgVCrx3//+F3PmzIFK1Toqnzlzpss5zqjQaDTCbvfNfiwtr52UlITSUvcqh4rlUuZ9IwdKSkraPObzXwsBAGN769o9JtSYAvQ8nvZ3Z3y/32/wTOsbLgU1+0uRHsFwyFiHMCXDuSlKr3+Putrfd5+ThIe+OYZvD0rTD8mRKkSJdSjppIx+sM0dFIXDZSbsL5emzlL1aoyMZ37//+jr3+9Q8JdMLdbuE+RaWIMTwnzej38dEYd71ktB/Sc/HcToFosgfjhmxt4iE9QKhtkD9C7P3d36++wEBZYB2HFUmlbWKBhGxgvd5nPCm/5WKpVuD0h4FNTo9XoIggCTyeRyv8lkajV601HjMjIyUFpa6nK/M6CpqKjAo48+2mrq6VTZ2dlwOBwwGo1ISWkdoapUqjaDHQB++8XlnLt1bd54MqemreNPmJuQXyGV7R+Xpu8W/9GCwd3+Pp1kx4ZhUKIOeWUWLP1JepM7P8uASLWiy33lbX8PiNfiytw4fNCcoDmuOVk51P/tlALwf+N64b6vjqGszoYbhidAYIFrd0/6/Y7UKHD5wFis+EVawXpmSrjPX1u6QYPLBsZiZV4l/r2zFLnNq8msdhFv7Za+SF42MBZxOmWbz91d+jspQoUz4rXY31yReUKmlOPYHdrekr/626NJbaVSiczMTOTl5cn3iaKIvLw8l9GYjoiiiMLCQkRHn0xqcgY0paWleOSRRxAZ2fmqiKNHj4IxBr0+dIew22XteIduX2+LQE4vlzUXVhQ5oGBSYmuwXTEwFsOTwxGmFOR6G91BVJgSz1+YjucvTGu1VJ545i/9o5Fu0CAxQlr95Q+zBsUiVa+GqdGBt5oTkz/dX4kKix0J4coub+IaKib1Pfl/aBolCLvw+BNz+vTpeP3115GZmYmsrCysX78eVqsV48ePBwC89tpriImJwZw5cwAAq1atQnZ2NpKSklBfX481a9bAaDRi0qRJAKSA5sUXX8SRI0fwwAMPQBRFeSQoIiICSqUS+fn5OHToEAYOHAitVov8/HwsX74c48aNQ0REN3yj6WD1kz+2RSCnl2HJ4ciI1uBItRXnpus73GE3UBQCwyMTUuEQedA3vPOUXqOA3o1CmaRjaoWAF6amgwF+W4WnUgj428gkPPhNITYW1GBAvBafNhfYvH54QrctsHmqsWl6bDtWiz4GTbfdzsBfPA5qRo8eDbPZjJUrV8JkMiE9PR0PPfSQPP1UUVHhktVcV1eHN954AyaTCeHh4cjMzMTChQuRmpoKAKiqqsKuXbsAAPfff7/Lcz322GMYOHAglEoltm/fjo8//hg2mw0JCQmYNm2aS85Mt9JBUOOvbRHI6YMxhjtHJePLQ9WYMzh06k8IjEFQhP7qDOI/gaiQPCBBh4tyDFiXb8JrP0lpDoMSdRjdg95PndV/SWuMd7eJuC4yGo0uS719gTGG5ORklJSUuDVH6Hj1KeC3n8Gu+xuEcRe4PLb0p1J8ddiEiZlRuOuctldGne487W/SNdTfgUX93XUWmwN3fnEERosdAgNemprebmE66u/A8qa/VSqV24nCPWMsrrtxjtSEuQ5pt9wWYQJNPRFCiFd0KgXuOCcZagXDzAEx3XqDRuIZykINhkYpUZidMv3ksi1CNy/bTwghwTQkKRwfXZnT7auFE8/QSE0wyDk1J0dqTA12fHbg5E6r9B+REEK6ht5HTz80UhMM8vRTGBwix5eHqvH+rxWot4lQCsxluR4hhBBC3ENBTTA016n5o0GFNzYcxZFqqdR135gw/PWsRKTqaYkeIYQQ4ikKagKMcw6TqMC7/a7A5t1ScBOhFnDNkHhckGUI2m7chBBCSHdHQU0AOUSODX9U4r0z70G9SkoEntw3CtcNjUdUGP1TEEIIIV1Bn6QBcqiyAUt/KkVBtRVQ6ZBRewK3zByJAYndsCIyIYQQEoIoqAmARruIJzYdR22TiHAlw5z9n+IC4x6o/zop2E0jhBBCegwKagKg2NyE2iYREWoBr43QQP/tj0BEzynZTQghhIQCqlMTACV1TQCAXno1DLx1jRpCCCGEdB0FNQFQWivtNZUUoe5wM0tCCCGEeI+CmgAobR6pSYpUUVBDCCGE+AkFNQHQcqSGt7OZJSGEEEK6hoKaAHCO1CRHqORqwjRSQwghhPgWBTV+ZnOIqLDYAQBJkWqgURqpOXWHbkIIIYR0DQU1flZWb4PIgTAlgyFM0eYO3YQQQgjpOgpq/MyZT5MYoQZj7OT0UxiN1BBCCCG+REGNn8krnyJU0h20+okQQgjxCwpq/Mw5UpMcqZbuaKTpJ0IIIcQfKKjxs1NHajitfiKEEEL8goIaPys5daSGpp8IIYQQv6Cgxo9EzlFW5yy855pTQ0u6CSGEEN+ioMaPqhrssIkcCgbEh5+SKEyrnwghhBCfoqDGj5xJwvHhKigEJt1JdWoIIYQQv6Cgxo9ObmSpPnlnIyUKE0IIIf5AQY0fyUnCznwagBKFCSGEED+hoMaPTo7UNC/nFh1Ak1V6kHbpJoQQQnyKgho/cubUJEU0Tz85AxqARmoIIYQQH6Ogxo9abZHgrCbMBEClbucsQgghhHiDgho/qbM6UNckAmiRKNxiOTdjLEgtI4QQQnomCmr8pKR5lCY6TIEwZXM30xYJhBBCiN9QUOMncj6Ny3JuqlFDCCGE+AsFNX5Scmo+DdBiObcmCC0ihBBCejYKavykzZEamn4ihBBC/IaCGj9ptfIJAKctEgghhBC/oaDGT5wjNckuIzW0QzchhBDiL0pvTtqwYQPWrl0Lk8mEtLQ0zJs3D1lZWW0eu2XLFixdutTlPpVKhffee0++zTnHypUrsXHjRtTX16N///646aabkJycLB9TV1eHt956C7t37wZjDCNHjsQNN9yAsBDc7dpqF1HZYAfQTk5NCLaZEEII6e48Dmq2b9+OFStWYP78+cjOzsa6deuwaNEiLFmyBFFRUW2eo9Vq8fLLL7d7zc8//xxffvklbr/9diQkJOCjjz7CokWL8OKLL0KtlkY6XnnlFVRXV+Phhx+Gw+HA0qVL8cYbb+Cuu+7y9CX4XVm9NEqjVQrQaxQnH6DVT4QQQojfeBzUfPHFF5g0aRImTJgAAJg/fz727NmDzZs3Y8aMGW2ewxiDwWBo8zHOOdavX49LL70UZ511FgDgb3/7G+bPn4+ff/4ZY8aMQVFREX755Rc888wz6Nu3LwBg3rx5eOaZZ3DttdciJiam1XVtNhtsNptLG7RarfyzLzmv5/y7rM6ZJKyCILSY4WtyjtRoqfheF5za38S/qL8Di/o7sKi/A8vf/e1RUGO321FQUOASvAiCgNzcXOTn57d7XmNjI2677TZwzpGRkYGrrroKvXv3BgCUl5fDZDJh8ODB8vE6nQ5ZWVnIz8/HmDFjkJ+fj/DwcDmgAYDc3FwwxnD48GGcffbZrZ5z9erVWLVqlXw7IyMDixcvRnx8vCcv2SNJSUkAgPoT0tRTRrzeZQqtSmCoB6CPi4e+xf3EO87+JoFB/R1Y1N/ea2hoQFlZGTjn4Jx3enxBQUEAWkWcWvY3YwyMMSQmJsoDD13hUVBjNpshimKrUReDwYDi4uI2z0lJScGtt96KtLQ0WCwWrFmzBg8//DBefPFFxMbGwmQyAUCrqauoqCj5MZPJBL1e7/K4QqFARESEfMypZs6cienTp8u3nVGh0WiE3W538xW7hzGGpKQklJaWgnOO/OIKAEC0SkRJSYl8nKO6CgBQ22RDfYv7iWdO7W/iX9TfgUX93TU2mw319fWIjIx0HSnvgEqlchnZJ/51an+LooijR48iPDwcKpWq1fFKpdLtAQmvEoU9kZOTg5ycHJfbd999N7755hvMnj3bb8+rUqna7BwAfnujcH4rKK09uZy75XPxRqlODdeE0ZuVD7j7LYz4BvV3YFF/e8disXgU0JDgEwQBkZGRqKurazWA4fG1PDlYr9dDEIRWoyMmk6ndnJlTKZVKZGRkoLS0FADk82pqalyOq6mpkR8zGAwwm80ujzscDtTV1bn9vP7EHQ44akzy7RJn4b2IU4IqqlNDCCF+RwFN9+OrfzOPrqJUKpGZmYm8vDz5PlEUkZeX5zIa0xFRFFFYWIjo6GgAQEJCAgwGA/bt2ycfY7FYcPjwYfmaOTk5qK+vd5mHy8vLA+e83aXkgcL37oDj3utRvfRZAIBD5Civd47UqF0PdtapoSXdhBBCiM95PP00ffp0vP7668jMzERWVhbWr18Pq9WK8ePHAwBee+01xMTEYM6cOQCAVatWITs7G0lJSaivr8eaNWtgNBoxadIkANL88UUXXYRPP/0UycnJSEhIwIcffojo6Gh5NVRqaiqGDh2KN954A/Pnz4fdbsdbb72F0aNHt7nyKaBi4oFaExp/3gph9s2otClgFwGlAMTqTule5zYJagpqCCGEEF/zOKgZPXo0zGYzVq5cCZPJhPT0dDz00EPyNFBFRYXLUq26ujq88cYbMJlMCA8PR2ZmJhYuXIjU1FT5mEsuuQRWqxVvvPEGLBYL+vfvj4ceekiuUQMAd955J5YtW4Ynn3xSLr43b968Lrx0H+mTCSSmgJcVg/+6E6V9zgQAJISroRBOWbLWSMX3CCGEEH9h/DTLRDMajT7Pchc/fw/8i4/Aho7Et1Nux+s/leLMlHA8OqG3y3GOO68CGuohPLUULCm1nauRzjDGkJycjJKSEkqkDADq78Ci/u4as9nscbJpT1j9lJCQgPr6etTX1we7KZ1qr7/b+7dTqVRur36ibCofEM4aBwDg+3ajpEr6hTo1SZhzfrL4HiUKE0IICYCEhASXWY+ezu9Luk8HrFcaVGl9YTv2J0pOlAPQIinylF8iux1wOKSfaUNLQggJCOkLpbXjY0QHuD9GatSaoFYqViqVEAQBTU1NQWtDoFFQ4yPac8+H7d0/UVrTCKi0bSznbjj5MwU1hBASGE1WiH+b1eEhHYc83hNeW+nW+71Op0NkZCTKyspc7o+OjgbnHLW1tdDr9VCr1WCMwW63w2w2dxqshIWFwWqVXh1jDFFRUdBopEDLWRaloaHB5ZyIiAjodDooFAo4HA5YLBbU1dVJr0cQoNfr5Y2k7XY7ampqQmrqjqaffEQ37gJwAKVMmlpqNVLjrFGjUoMpFCCEEEIAaVsHQRBcpokYYwgLC4PFYgFjDFarFZWVlTAajbBarYiNjYWik8+SsLAwNDYvUGGMwWazydewWCwwGAwuRWojIyMRERGB2tpaeQsjURTl8+Pi4qBQKFBVVQWj0SgHO6GERmp8RNWrD8zpA9GglCLYxPBTRmrkHbpplIYQQgJGrZFGTDrgt0RhtcatwzjnaGxshFarlUdftFotRFGUb7fc3qe2thZhYWHQaDSwWCxtXlMQBKhUKjmoEUXRJYm4vr4eGo0GWq0WNpsNjDFERESgpqZGHr1xOBwu7REEAUajUU5gdzhTKkIIBTU+VD7kXKAGiHHUQ6M8ZRDMOf1EQQ0hhAQMY6zT912mUoEJwR1Bb2hogMFgkKvra7VaObhgjCEyMhIajUYenWGMQals/yM8LCwMTU1NLivoIiIioNVqXa7hfFypVMojQm1xBn6hviKPghofKk3LBX6rQ1JtGbipEswQe/JB5/RTGK18IoQQ4so5ouIMRtRqtbw9kF6vh0ajgdlsht1uB+e808KzLaeeACmgCQ8Ph9lsloOTlhtJdxashHow40Q5NT5UBunbQFJDJfju7a4P0kgNIYSQDjinoHQ6Hex2uzwlplarYbFY0NjYCLvdDlEUO8ynYYxBo9G4BDVqtRqNjY1oaGiA3W6Hw+FwGelxXlejaXvKzGazQaVSBXU1lzsoqPGhkrrmjSwbKsF/3uryGKecGkIIIR2wWCwICwtzmXoCpIBDq9VCqVRCqVTKeye2R6PRyIFLy2toNBqoVCoolUpERUW12kTSuUu2c4pKpVJBp9MBkKbHRFFETEwM1Go1FAoFwsLCXBKNQwFNP/lQaW3zRpaNVUDhH+CV5WCxCdKDVgpqCCGEtK+pqQmiKEKlUqGqqkq+32w2w2AwIC4uDqIooq6ursMRk1OnngApuVihUCA2Nhacc3nk59RtjQBpFVTLJd1OlZWV0Ov18tSXc0l3KKGgxoecQU1iggEoB/iuH8CmXCo92Dz9xCioIYQQ0o5Ta9UA0iqjyspKl/tOXfVUXl4u/xwWFtbqeM45qqurO33+urq6dpdqOxwOt64RTDT95CMNTQ5UN0pDfcmDBwEA+M4WU1CNtEUCIYQQ/xIEAXV1dSFVEC+QKKjxkRM10khMuFqAfsQoQBCAwj/By4qlA6y0QzchhBD/ck5Pna4oqPGRIpMU1CRFqMEi9cCAIQBwMmG4iXJqCCGEEH+ioMZHnEFNcqSUCc7OOhdAi6CGpp8IIYQQv6KgxkdajtQAABs2ElAqgeJC8BPHwKlODSGEEOJXFNT4yIlTR2p0EcDA4QCaR2sop4YQQgjxKwpqfOTUkRoAYGeNA9Ac1DQ6l3TT9BMhhBDiD1SnxgccIkeJWRqJSYo8WV2RDTkbXK0GyksAU3PNAJp+IoQQQvyCRmp8wFhvg0PkUAkMMdqTcSIL04LlniXdaN6+nYIaQgghxD8oqPGBEuf2CJEqCKeUrmZnj3M9mHbpJoQQ4kcJCQkIDw8PdjOCgoIaH5A3smyRTyMbdKbrMm512zugEkIIOX3FxsZCr9f75FoVFRWttlFwh0KhQHJycsjvxN0RyqnxgdIWIzWnYmoN2LCR4Du2SHfQSA0hhAQM5xxWB+/wGAdE2Oyiz59bo2BBCRBE0bvXEhYWBqvVCs477q9QRkGND5TWSUFNclsjNQDYiHEngxrKqSGEkICxOjiu/Cg/KM/90ZU5CFN2HtQYDAZoNBpoNBpEREQAAKqrqxEdHY3KykpERkZCpVKhsrISDocDer0earUajDHY7XaYzWY0OfM2IU0/1dfXo76+HgCQkpICk8kkP4coiqipqYHVanVpR1hYGBoapJW6KpUKer0eSqUSjDHYbDaYzWaXPaUYY9Dr9QgLC4MgCHJbnNdVq9Vy2wFpF3J/b4hJQY0PlNQ2Tz9Fth3UYOBQoF8uoAsHVO0cQwgh5LRUU1MDpVIJm82G2tpaAIBSKX086/V6mM1m2O12iKIIhUIBq9WK2tpacM6h0+kQGxuL8vJyOByOdp8jMjISZrMZZrMZ4eHhiI6ORllZmTwqwxiDWq2Wgw7GGCwWixzEhIeHIyYmBuXl5fI5sbGxYIzBZDLBbrfLbXa2PzY2FhaLBTU1NQAgB2L+REFNF3HOUdY8UpMU0Xr6CQCYUgXFvYsC2SxCCCGQpoA+ujKnw2NUShVsdt/vaq1RuPcBzjmX/5w6dVRbW+syomK322G3210eDwsLg0aj6TCPxmKxyKMwtbW1iIiIgFqtlq8dFhYGm80mP3/LkR9ACry0Wq18jkajgUqlcgmmWgZVERERaGpqkgMaZ9sBKXfHXyio6SJTowONdg4GILGdoIYQQkhwMMY6nQJSqQQoQnTdzKnBBWMMkZGR0Gg0cnDAGHMZJWlLy2kjZ/AkCCdfc1hYGBqdexQCEARBfh7ncYwx+TlVKhUcDke7o0MqlcrleoFCQU0XOZOEE/UaqBRCt06wIoQQElpO/UzR6/XQaDTylBTnHDExMV1+Ho1GI099AVKejyAIqKmpgcPhAOcccXFx8vRRZ591wfospKCmi+qaRISrBKQaaFUTIYQQ77gbBKjValgsFnkUpOXoibecycMtp7XUarVLMrEgCC7PY7PZoFAooFAo2hytsdvtUKsDn0NKQU0XnZUagfdn5SAmPhHVFeXBbg4hhJBuyOFwQK1WQ6FQdBjg2O12aLVaOajxRW2bU6eeWj6PzWaTVzm1zPdpampCU1MTYmJi5FEj5xSYM5E5ISEBUVFR8iostVrt9ymp0JxE7GYYYwhT+S/xiRBCSM9WV1cHAIiPj0dSUlK7oy9msxmiKCIuLg4xMTFobGx0yZfxhkajaRVsmEwmCIKA+Ph4REdHo76+vlUSc1VVFWw2GwwGAxISElwCLIfDgcrKSqhUKsTHxyMuLg5hYWF+n5aikRpCCCEkyBwOByoqKlzuc65WOvW4yspKl/tOXfVUXu46a1BcXNzqOqWlpQCkhF5BEFolJNvt9lbtOTXw4ZzDZDK18WokTU1Nra7hbzRSQwghhJzGWi677u5opIYQQgg5Tdlsti5PX4USGqkhhBBCSI9AQQ0hhBBCegSvpp82bNiAtWvXwmQyIS0tDfPmzUNWVlan523btg0vv/wyRowYgfvvv1++f9asWW0ef8011+Diiy8GANx+++0wGo0uj8+ZMwczZszw5iUQQgjpoU6tlktCn7c7i5/K46Bm+/btWLFiBebPn4/s7GysW7cOixYtwpIlSxAVFdXueeXl5Xj33XcxYMCAVo/95z//cbm9d+9e/Pvf/8bIkSNd7p81axYmT54s3w4Lox2vCSGEnKTT6VBbW4vIyEgKbLoJURRRW1uL8PDwLl/L46Dmiy++wKRJkzBhwgQAwPz587Fnzx5s3ry53VETURTx6quvYtasWThw4IBciMfJYDC43P75558xcOBAJCYmutyv1WpbHUsIIYQ4KZVKhIeHy3Vf3KFWq1staSb+01Z/h4eHd7p/lTs8uoLdbkdBQYFL8CIIAnJzc5Gfn9/ueatWrYJer8fEiRNx4MCBDp/DZDJh7969uP3221s99tlnn+GTTz5BXFwcxo4di2nTprVboOjUjG7GGLRarfyzLzmv5+8t1YmE+juwqL8Di/q761QqVYczBy0xxpCUlITS0lLauy8A/N3fHgU1zkqGp46WGAyGNov7AMAff/yBTZs24bnnnnPrOb777juEhYXh7LPPdrl/6tSpyMjIQEREBA4ePIgPPvgA1dXVmDt3bpvXWb16NVatWiXfzsjIwOLFixEfH+9WO7yRlJTkt2uT1qi/A4v6O7CovwOL+juw/NXffq1T09DQgFdffRW33HKL2/tTbN68GePGjWu1Edb06dPln9PS0qBUKvHf//4Xc+bMgUqlanWdmTNnupzj/NZjNBpdNu3yBYr0A4v6O7CovwOL+juwqL8Dy5v+ViqVbg9IeBTU6PV6CILQqiyyyWRqM9elrKwMRqMRixcvlu9zvojZs2djyZIlLtHagQMHUFxcjL///e+dtiU7OxsOhwNGoxEpKSmtHlepVG0GOy3b4Gucc/pPEUDU34FF/R1Y1N+BRf0dWP7qb4+CGqVSiczMTOTl5cnTQ6IoIi8vDxdeeGGr41NSUvD888+73Pfhhx+isbER119/PeLi4lwe27RpEzIzM5Gent5pW44ePSrvHEoIIYQQ4vH00/Tp0/H6668jMzMTWVlZWL9+PaxWK8aPHw8AeO211xATE4M5c+ZArVajT58+Luc7l2yder/FYsGOHTtw7bXXtnrO/Px8HDp0CAMHDoRWq0V+fj6WL1+OcePGISIiwqP2+yK7OhjXJq1RfwcW9XdgUX8HFvV3YHnS3x4d62lDRo8eDbPZjJUrV8JkMiE9PR0PPfSQPP1UUVHhVdb+9u3bwTnH2LFjWzdSqcT27dvx8ccfw2azISEhAdOmTXPJmXFXdHS0x+e4y59JyKQ16u/Aov4OLOrvwKL+Diy/9TcnXWaxWPj999/PLRZLsJtyWqD+Dizq78Ci/g4s6u/A8nd/U7lFH+Cc48iRI5RkFiDU34FF/R1Y1N+BRf0dWP7ubwpqCCGEENIjUFBDCCGEkB6BghofUKlUuPzyy9uti0N8i/o7sKi/A4v6O7CovwPL3/3NOE0kEkIIIaQHoJEaQgghhPQIFNQQQgghpEegoIYQQgghPQIFNYQQQgjpEWiziy7asGED1q5dC5PJhLS0NMybNw9ZWVnBblaPsH//fqxZswZHjhxBdXU17r33XnkjVUAq4rRy5Ups3LgR9fX16N+/P2666SYkJycHsdXd0+rVq7Fz506cOHECarUaOTk5uOaaa5CSkiIf09TUhBUrVmD79u2w2WwYMmQIbrrpJnmLFOK+r7/+Gl9//TWMRiMAIDU1FZdffjmGDRsGgPra3z777DO8//77uOiii3D99dcDoD73pZUrV2LVqlUu96WkpGDJkiUA/NvXNFLTBdu3b8eKFStw+eWXY/HixUhLS8OiRYtQU1MT7Kb1CFarFenp6bjxxhvbfPzzzz/Hl19+ifnz5+Ppp5+GRqPBokWL0NTUFOCWdn/79+/HlClTsGjRIjz88MNwOBxYuHAhGhsb5WOWL1+O3bt345577sETTzyB6upqvPDCC0Fsdffl3PT32WefxTPPPINBgwbhueeew/HjxwFQX/vT4cOH8c033yAtLc3lfupz3+rduzf+85//yH+efPJJ+TG/9rVfNl84TTz44IP8zTfflG87HA5+880389WrVwevUT3UFVdcwX/66Sf5tiiKfP78+fzzzz+X76uvr+dz5szhP/zwQzCa2KPU1NTwK664gv/++++cc6lvZ8+ezX/88Uf5mKKiIn7FFVfwgwcPBquZPcr111/PN27cSH3tRw0NDfzOO+/kv/76K3/sscf422+/zTmn329f++ijj/i9997b5mP+7msaqfGS3W5HQUEBcnNz5fsEQUBubi7y8/OD2LLTQ3l5OUwmEwYPHizfp9PpkJWVRf3vAxaLBQAQEREBACgoKIDD4XD5fe/Vqxfi4uKov7tIFEVs27YNVqsVOTk51Nd+9Oabb2LYsGEu7xsA/X77Q2lpKW655Rb87W9/wyuvvIKKigoA/u9ryqnxktlshiiKreYADQYDiouLg9Oo04jJZAIAREVFudwfFRUlP0a8I4oi3nnnHfTr1w99+vQBIPW3UqlEeHi4y7HU394rLCzEggULYLPZEBYWhnvvvRepqak4evQo9bUfbNu2DUeOHMEzzzzT6jH6/fat7Oxs3HbbbUhJSUF1dTVWrVqFRx99FC+88ILf+5qCGkKIi2XLluH48eMuc+DE91JSUvDPf/4TFosFO3bswOuvv44nnngi2M3qkSoqKvDOO+/g4YcfhlqtDnZzejxnwjsApKWlyUHOjz/+6Pf+p6DGS3q9HoIgtIosTSYTZcsHgLOPa2pqEB0dLd9fU1OD9PT04DSqB1i2bBn27NmDJ554ArGxsfL9BoMBdrsd9fX1Lt+wampq6PfdS0qlEklJSQCAzMxM/Pnnn1i/fj1Gjx5Nfe1jBQUFqKmpwQMPPCDfJ4oiDhw4gA0bNmDBggXU534UHh6OlJQUlJaWYvDgwX7ta8qp8ZJSqURmZiby8vLk+0RRRF5eHnJycoLYstNDQkICDAYD9u3bJ99nsVhw+PBh6n8vcM6xbNky7Ny5E48++igSEhJcHs/MzIRCoXDp7+LiYlRUVFB/+4goirDZbNTXfpCbm4vnn38ezz33nPynb9++GDt2rPwz9bn/NDY2orS0FAaDwe+/3zRS0wXTp0/H66+/jszMTGRlZWH9+vWwWq0YP358sJvWIzj/IziVl5fj6NGjiIiIQFxcHC666CJ8+umnSE5ORkJCAj788ENER0fjrLPOCmKru6dly5bhhx9+wP333w+tViuPQOp0OqjVauh0OkycOBErVqxAREQEdDod3nrrLeTk5NCbvhfef/99DB06FHFxcWhsbMQPP/yA/fv3Y8GCBdTXfqDVauX8MCeNRoPIyEj5fupz31mxYgVGjBiBuLg4VFdXY+XKlRAEAWPHjvX77zft0t1FGzZswJo1a2AymZCeno4bbrgB2dnZwW5Wj/D777+3mWNw3nnn4fbbb5eL73377bewWCzo378/brzxRpeCccQ9s2bNavP+2267TQ7SnQWztm3bBrvdTsXJuuBf//oX8vLyUF1dDZ1Oh7S0NFxyySXyqhzqa/97/PHHkZ6e3qr4HvV51y1ZsgQHDhxAbW0t9Ho9+vfvj9mzZ8vTrf7sawpqCCGEENIjUE4NIYQQQnoECmoIIYQQ0iNQUEMIIYSQHoGCGkIIIYT0CBTUEEIIIaRHoKCGEEIIIT0CBTWEEEII6REoqCGEEEJIj0BBDSGEAFi5ciVmzZoFs9kc7KYQQrxEQQ0hhBBCegQKagghhBDSI1BQQwghhJAeQRnsBhBCTi9VVVX48MMPsXfvXtTX1yMpKQnTp0/HxIkTAZzcnf3vf/87jh49is2bN6OxsRGDBg3CjTfeiLi4OJfr/fjjj/jss89QVFSEsLAwDBkyBNdccw1iYmJcjjtx4gQ++ugj/P7772hsbERcXBxGjRqFq666yuU4i8WCd999Fz///DM45xg5ciRuvPFGaDQa/3YMIaTLKKghhASMyWTCggULAABTpkyBXq/HL7/8gn//+99oaGjAtGnT5GM//fRTMMZwySWXwGw2Y926dXjqqafwz3/+E2q1GgCwZcsWLF26FH379sWcOXNQU1OD9evX4+DBg3juuecQHh4OADh27BgeffRRKJVKTJo0CQkJCSgtLcXu3btbBTUvvfQS4uPjMWfOHBQUFGDTpk3Q6/W45pprAtRLhBBvUVBDCAmYDz/8EKIo4vnnn0dkZCQA4IILLsCSJUvw8ccf4/zzz5ePraurw0svvQStVgsAyMjIwEsvvYRvv/0WF110Eex2O9577z307t0bTzzxhBzo9O/fH88++yzWrVuHWbNmAQDeeustAMDixYtdRnquvvrqVm1MT0/Hrbfe6tKOzZs3U1BDSDdAOTWEkIDgnOOnn37CmWeeCc45zGaz/Gfo0KGwWCwoKCiQjz/33HPlgAYARo0ahejoaOzduxcAUFBQgJqaGkyZMkUOaABg+PDh6NWrF/bs2QMAMJvNOHDgACZMmNBq6oox1qqdLQMrQAqSamtrYbFYut4JhBC/opEaQkhAmM1m1NfX49tvv8W3337b7jHOKaPk5GSXxxhjSEpKgtFoBAD575SUlFbXSUlJwR9//AEAKCsrAwD07t3brXaeGvhEREQAAOrr66HT6dy6BiEkOCioIYQEBOccADBu3Dicd955bR6TlpaGoqKiQDarFUFoewDb2X5CSOiioIYQEhB6vR5arRaiKGLw4MHtHucMakpKSlzu55yjtLQUffr0AQDEx8cDAIqLizFo0CCXY4uLi+XHExMTAQDHjx/3zQshhIQsyqkhhASEIAgYOXIkfvrpJxQWFrZ6/NTtCb7//ns0NDTIt3fs2IHq6moMGzYMAJCZmYmoqCh88803sNls8nF79+7FiRMnMHz4cABSMDVgwABs3rwZFRUVLs9Boy+E9Cw0UkMICZg5c+bg999/x4IFCzBp0iSkpqairq4OBQUF2LdvH95++2352IiICDz66KMYP348ampqsG7dOiQlJWHSpEkAAKVSiauvvhpLly7F448/jjFjxsBkMuHLL79EfHy8y/LwG264AY8++igeeOABeUm30WjEnj178M9//jPg/UAI8Q8KagghAWMwGPD0009j1apV+Omnn/DVV18hMjLy/9u5e9sIgSAAo+MEKiCkBEIkyGiB/MKr4HqgFAIyiKmGKpBI7MCyJcvx+Wf0XgW72afV7ERd19++V4/jGMdxxLqucZ5nNE0T9/v9yxK8YRiiKIrYti3meY6yLKNt27jdbp8DxxHv37SnaYplWWLf97iuK6qqir7vf+zuwPO9vHp/Bf6Qj43Cj8cjuq777eMA/4iZGgAgBVEDAKQgagCAFMzUAAApeKkBAFIQNQBACqIGAEhB1AAAKYgaACAFUQMApCBqAIAURA0AkMIbe9EXhvorfVMAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -2272,6 +3145,26 @@ "rs['testval_metrics'] = rs['test']\n" ] }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "10470.0" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "0.2094*50000\n" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -2281,7 +3174,7 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 42, "metadata": {}, "outputs": [ { @@ -2295,21 +3188,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Testing DataLoader 0: 11%|█ | 2/18 [00:00<00:00, 18.15it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/media/wassname/SGIronWolf/projects5/elk/discovering_latent_knowledge/.venv/lib/python3.10/site-packages/lightning/pytorch/trainer/connectors/logger_connector/result.py:211: You called `self.log('test/n', ...)` in your `test_step` but the value needs to be floating point. Converting it to torch.float32.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Testing DataLoader 0: 100%|██████████| 18/18 [00:01<00:00, 15.91it/s]\n" + "Testing DataLoader 0: 100%|██████████| 18/18 [00:00<00:00, 25.58it/s]\n" ] }, { @@ -2318,11 +3197,11 @@ "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
        "┃        Test metric        ┃       DataLoader 0        ┃\n",
        "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
-       "│         test/acc          │    0.4210045635700226     │\n",
-       "│       test/l1_loss        │     16.12659454345703     │\n",
-       "│       test/l2_loss        │     2273.49072265625      │\n",
-       "│      test/loss_pred       │    0.1512577384710312     │\n",
-       "│       test/loss_rec       │     2273.538818359375     │\n",
+       "│         test/acc          │    0.2511415481567383     │\n",
+       "│       test/l1_loss        │     94.82392883300781     │\n",
+       "│       test/l2_loss        │     6796.65478515625      │\n",
+       "│      test/loss_pred       │    1.0872248411178589     │\n",
+       "│       test/loss_rec       │     6806.13720703125      │\n",
        "│          test/n           │          1095.0           │\n",
        "└───────────────────────────┴───────────────────────────┘\n",
        "
\n" @@ -2331,11 +3210,11 @@ "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", "┃\u001b[1m \u001b[0m\u001b[1m Test metric \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m DataLoader 0 \u001b[0m\u001b[1m \u001b[0m┃\n", "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", - "│\u001b[36m \u001b[0m\u001b[36m test/acc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.4210045635700226 \u001b[0m\u001b[35m \u001b[0m│\n", - "│\u001b[36m \u001b[0m\u001b[36m test/l1_loss \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 16.12659454345703 \u001b[0m\u001b[35m \u001b[0m│\n", - "│\u001b[36m \u001b[0m\u001b[36m test/l2_loss \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 2273.49072265625 \u001b[0m\u001b[35m \u001b[0m│\n", - "│\u001b[36m \u001b[0m\u001b[36m test/loss_pred \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.1512577384710312 \u001b[0m\u001b[35m \u001b[0m│\n", - "│\u001b[36m \u001b[0m\u001b[36m test/loss_rec \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 2273.538818359375 \u001b[0m\u001b[35m \u001b[0m│\n", + "│\u001b[36m \u001b[0m\u001b[36m test/acc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.2511415481567383 \u001b[0m\u001b[35m \u001b[0m│\n", + "│\u001b[36m \u001b[0m\u001b[36m test/l1_loss \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 94.82392883300781 \u001b[0m\u001b[35m \u001b[0m│\n", + "│\u001b[36m \u001b[0m\u001b[36m test/l2_loss \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 6796.65478515625 \u001b[0m\u001b[35m \u001b[0m│\n", + "│\u001b[36m \u001b[0m\u001b[36m test/loss_pred \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 1.0872248411178589 \u001b[0m\u001b[35m \u001b[0m│\n", + "│\u001b[36m \u001b[0m\u001b[36m test/loss_rec \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 6806.13720703125 \u001b[0m\u001b[35m \u001b[0m│\n", "│\u001b[36m \u001b[0m\u001b[36m test/n \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 1095.0 \u001b[0m\u001b[35m \u001b[0m│\n", "└───────────────────────────┴───────────────────────────┘\n" ] @@ -2354,7 +3233,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Predicting DataLoader 0: 100%|██████████| 5/5 [00:00<00:00, 17.13it/s]\n" + "Predicting DataLoader 0: 100%|██████████| 5/5 [00:00<00:00, 29.22it/s]\n" ] }, { @@ -2368,15 +3247,15 @@ "name": "stdout", "output_type": "stream", "text": [ - "Predicting DataLoader 0: 100%|██████████| 5/5 [00:00<00:00, 20.42it/s]\n", + "Predicting DataLoader 0: 100%|██████████| 5/5 [00:00<00:00, 34.40it/s]\n", "probe results on subsets of the data\n", - "acc=38.69%,\tn=548,\t[] \n", - "acc=39.02%,\tn=205,\t[instructed_to_lie==True] \n", - "acc=38.48%,\tn=343,\t[instructed_to_lie==False] \n", - "acc=41.15%,\tn=503,\t[llm_ans==label_true] \n", - "acc=35.31%,\tn=388,\t[llm_ans==label_instructed] \n", - "acc=11.11%,\tn=45,\t[instructed_to_lie==True & llm_ans==label_instructed] \n", - "acc=46.88%,\tn=160,\t[instructed_to_lie==True & llm_ans!=label_instructed] \n", + "acc=22.99%,\tn=548,\t[] \n", + "acc=26.34%,\tn=205,\t[instructed_to_lie==True] \n", + "acc=20.99%,\tn=343,\t[instructed_to_lie==False] \n", + "acc=25.05%,\tn=503,\t[llm_ans==label_true] \n", + "acc=18.56%,\tn=388,\t[llm_ans==label_instructed] \n", + "acc=0.00%,\tn=45,\t[instructed_to_lie==True & llm_ans==label_instructed] \n", + "acc=33.75%,\tn=160,\t[instructed_to_lie==True & llm_ans!=label_instructed] \n", "probe accuracy for quadrants\n" ] }, @@ -2413,13 +3292,13 @@ " \n", " \n", " tell a truth\n", - " 0.38\n", + " 0.21\n", " NaN\n", " \n", " \n", " tell a lie\n", - " 0.11\n", - " 0.47\n", + " 0.00\n", + " 0.34\n", " \n", " \n", "\n", @@ -2428,8 +3307,8 @@ "text/plain": [ "llm gave did didn't\n", "instructed to \n", - "tell a truth 0.38 NaN\n", - "tell a lie 0.11 0.47" + "tell a truth 0.21 NaN\n", + "tell a lie 0.00 0.34" ] }, "metadata": {}, @@ -2439,55 +3318,55 @@ "name": "stdout", "output_type": "stream", "text": [ - "⭐PRIMARY METRIC⭐ acc=38.69% from probe\n", - "⭐SECONDARY METRIC⭐ acc_lie_lie=11.11% from probe\n" + "⭐PRIMARY METRIC⭐ acc=22.99% from probe\n", + "⭐SECONDARY METRIC⭐ acc_lie_lie=0.00% from probe\n" ] }, { "data": { "text/plain": [ - "{'train': {'acc': 0.5563439130783081,\n", - " 'loss_pred': 0.13514529168605804,\n", - " 'loss_rec': 1053.4332275390625,\n", - " 'l1_loss': 21.259716033935547,\n", - " 'l2_loss': 1053.3695068359375,\n", + "{'train': {'acc': 0.1719532608985901,\n", + " 'loss_pred': 1.8178952932357788,\n", + " 'loss_rec': 6069.33203125,\n", + " 'l1_loss': 107.15355682373047,\n", + " 'l2_loss': 6058.6162109375,\n", " 'n': 2396.0},\n", - " 'val': {'acc': 0.6093488931655884,\n", - " 'loss_pred': 0.07309918850660324,\n", - " 'loss_rec': 2235.301025390625,\n", - " 'l1_loss': 20.227296829223633,\n", - " 'l2_loss': 2235.240478515625,\n", + " 'val': {'acc': 0.6460767984390259,\n", + " 'loss_pred': 0.9434764385223389,\n", + " 'loss_rec': 7249.103515625,\n", + " 'l1_loss': 96.78995513916016,\n", + " 'l2_loss': 7239.423828125,\n", " 'n': 1198.0},\n", - " 'test': {'acc': 0.5993322134017944,\n", - " 'loss_pred': 0.2141098976135254,\n", - " 'loss_rec': 2699.653564453125,\n", - " 'l1_loss': 19.770179748535156,\n", - " 'l2_loss': 2699.593994140625,\n", + " 'test': {'acc': 0.37896493077278137,\n", + " 'loss_pred': 1.302729845046997,\n", + " 'loss_rec': 7144.57275390625,\n", + " 'l1_loss': 97.97341918945312,\n", + " 'l2_loss': 7134.775390625,\n", " 'n': 1198.0,\n", - " 'acc_lie_lie': 0.29770992366412213},\n", - " 'oos': {'acc': 0.4210045635700226,\n", - " 'loss_pred': 0.1512577384710312,\n", - " 'loss_rec': 2273.538818359375,\n", - " 'l1_loss': 16.12659454345703,\n", - " 'l2_loss': 2273.49072265625,\n", + " 'acc_lie_lie': 0.061068702290076333},\n", + " 'oos': {'acc': 0.2511415481567383,\n", + " 'loss_pred': 1.0872248411178589,\n", + " 'loss_rec': 6806.13720703125,\n", + " 'l1_loss': 94.82392883300781,\n", + " 'l2_loss': 6796.65478515625,\n", " 'n': 1095.0,\n", - " 'acc_lie_lie': 0.1111111111111111},\n", - " 'testval_metrics': {'acc': 0.5993322134017944,\n", - " 'loss_pred': 0.2141098976135254,\n", - " 'loss_rec': 2699.653564453125,\n", - " 'l1_loss': 19.770179748535156,\n", - " 'l2_loss': 2699.593994140625,\n", + " 'acc_lie_lie': 0.0},\n", + " 'testval_metrics': {'acc': 0.37896493077278137,\n", + " 'loss_pred': 1.302729845046997,\n", + " 'loss_rec': 7144.57275390625,\n", + " 'l1_loss': 97.97341918945312,\n", + " 'l2_loss': 7134.775390625,\n", " 'n': 1198.0,\n", - " 'acc_lie_lie': 0.29770992366412213},\n", - " 'oos_metrics': {'test/acc': 0.4210045635700226,\n", - " 'test/loss_pred': 0.1512577384710312,\n", - " 'test/loss_rec': 2273.538818359375,\n", - " 'test/l1_loss': 16.12659454345703,\n", - " 'test/l2_loss': 2273.49072265625,\n", + " 'acc_lie_lie': 0.061068702290076333},\n", + " 'oos_metrics': {'test/acc': 0.2511415481567383,\n", + " 'test/loss_pred': 1.0872248411178589,\n", + " 'test/loss_rec': 6806.13720703125,\n", + " 'test/l1_loss': 94.82392883300781,\n", + " 'test/l2_loss': 6796.65478515625,\n", " 'test/n': 1095.0}}" ] }, - "execution_count": 39, + "execution_count": 42, "metadata": {}, "output_type": "execute_result" } @@ -2504,32 +3383,979 @@ ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], - "source": [] + "source": [ + "# End to end?\n" + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 43, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Trainer will use only 1 of 2 GPUs because it is running inside an interactive / notebook environment. You may try to set `Trainer(devices=2)` but please note that multi-GPU inside interactive / notebook environments is considered experimental and unstable. Your mileage may vary.\n", + "Using 16bit Automatic Mixed Precision (AMP)\n", + "GPU available: True (cuda), used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", + "\n", + " | Name | Type | Params\n", + "-------------------------------------\n", + "0 | ae | AutoEncoder | 3.7 M \n", + "1 | head | Sequential | 28.8 K\n", + "-------------------------------------\n", + "3.7 M Trainable params\n", + "0 Non-trainable params\n", + "3.7 M Total params\n", + "14.760 Total estimated model params size (MB)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "requires_grad: True, AutoEncoder(\n", + " (enc): Encoder(\n", + " (conv): Sequential(\n", + " (0): BatchNorm1d(4096, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (1): InceptionBlock(\n", + " (bottleneck): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 4097, 64, kernel_size=(1,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (convs): ModuleList(\n", + " (0): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 65, 64, kernel_size=(7,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (1): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 65, 64, kernel_size=(5,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (2): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 65, 64, kernel_size=(3,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (mp_conv): Sequential(\n", + " (0): MaxPool1d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n", + " (1): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 4097, 64, kernel_size=(1,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (bn): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv_dropout): Dropout(p=0, inplace=False)\n", + " (act): ReLU()\n", + " )\n", + " (2): InceptionBlock(\n", + " (bottleneck): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 257, 64, kernel_size=(1,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (convs): ModuleList(\n", + " (0): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 65, 64, kernel_size=(7,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (1): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 65, 64, kernel_size=(5,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (2): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 65, 64, kernel_size=(3,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (mp_conv): Sequential(\n", + " (0): MaxPool1d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n", + " (1): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 257, 64, kernel_size=(1,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (bn): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv_dropout): Dropout(p=0, inplace=False)\n", + " (act): ReLU()\n", + " )\n", + " (3): InceptionBlock(\n", + " (bottleneck): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 257, 64, kernel_size=(1,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (convs): ModuleList(\n", + " (0): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 65, 64, kernel_size=(7,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (1): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 65, 64, kernel_size=(5,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (2): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 65, 64, kernel_size=(3,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (mp_conv): Sequential(\n", + " (0): MaxPool1d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n", + " (1): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 257, 64, kernel_size=(1,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (bn): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv_dropout): Dropout(p=0, inplace=False)\n", + " (act): ReLU()\n", + " )\n", + " (4): InceptionBlock(\n", + " (bottleneck): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 257, 64, kernel_size=(1,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (convs): ModuleList(\n", + " (0): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 65, 64, kernel_size=(7,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (1): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 65, 64, kernel_size=(5,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (2): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 65, 64, kernel_size=(3,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (mp_conv): Sequential(\n", + " (0): MaxPool1d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n", + " (1): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 257, 64, kernel_size=(1,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (bn): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv_dropout): Dropout(p=0, inplace=False)\n", + " (act): ReLU()\n", + " )\n", + " )\n", + " (fc): Sequential(\n", + " (0): LinBnDrop(\n", + " (lin): Linear(in_features=6912, out_features=324, bias=True)\n", + " (bn): BatchNorm1d(324, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act): ReLU()\n", + " )\n", + " (1): Linear(in_features=324, out_features=324, bias=True)\n", + " )\n", + " )\n", + " (dec): Decoder(\n", + " (fc): Sequential(\n", + " (0): BatchNorm1d(324, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (1): LinBnDrop(\n", + " (lin): Linear(in_features=324, out_features=432, bias=True)\n", + " (bn): BatchNorm1d(432, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act): ReLU()\n", + " )\n", + " (2): ReLU()\n", + " )\n", + " (conv): Sequential(\n", + " (0): InceptionBlock(\n", + " (convs): ModuleList(\n", + " (0): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 17, 16, kernel_size=(7,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (1): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 17, 16, kernel_size=(5,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (2): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 17, 16, kernel_size=(3,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (mp_conv): Sequential(\n", + " (0): MaxPool1d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n", + " (1): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 17, 16, kernel_size=(1,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (bn): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv_dropout): Dropout(p=0, inplace=False)\n", + " (act): ReLU()\n", + " )\n", + " (1): InceptionBlock(\n", + " (bottleneck): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 65, 16, kernel_size=(1,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (convs): ModuleList(\n", + " (0): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 17, 16, kernel_size=(7,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (1): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 17, 16, kernel_size=(5,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (2): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 17, 16, kernel_size=(3,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (mp_conv): Sequential(\n", + " (0): MaxPool1d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n", + " (1): ConvBlock(\n", + " (0): AddCoords1d()\n", + " (1): ParametrizedConv1d(\n", + " 65, 16, kernel_size=(1,), stride=(1,), padding=same, bias=False\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " (2): ReLU()\n", + " (3): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (bn): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv_dropout): Dropout(p=0, inplace=False)\n", + " (act): ReLU()\n", + " )\n", + " (2): ParametrizedConv1d(\n", + " 64, 4096, kernel_size=(1,), stride=(1,)\n", + " (parametrizations): ModuleDict(\n", + " (weight): ParametrizationList(\n", + " (0): _WeightNorm()\n", + " )\n", + " )\n", + " )\n", + " )\n", + " )\n", + ")\n", + "Epoch 49: 100%|██████████| 38/38 [00:05<00:00, 7.45it/s, v_num=124, val/loss_pred=0.109, val/loss_rec=4.21e+3, train/loss_pred=0.0837, train/loss_rec=530.0] " + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_epochs=50` reached.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 49: 100%|██████████| 38/38 [00:05<00:00, 7.27it/s, v_num=124, val/loss_pred=0.109, val/loss_rec=4.21e+3, train/loss_pred=0.0837, train/loss_rec=530.0]\n" + ] + } + ], + "source": [ + "net.ae_mode(2)\n", + "trainer2 = pl.Trainer(precision=\"16-mixed\",\n", + " gradient_clip_val=20,\n", + " max_epochs=max_epochs, log_every_n_steps=3, \n", + " # enable_progress_bar=False, enable_model_summary=False\n", + " )\n", + "trainer2.fit(model=net, train_dataloaders=dl_train, val_dataloaders=dl_val)\n" + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 44, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Testing DataLoader 3: 100%|██████████| 18/18 [00:00<00:00, 29.62it/s]\n" + ] + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
+       "┃        Test metric        ┃       DataLoader 0        ┃       DataLoader 1        ┃       DataLoader 2        ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
+       "│         test/acc          │    0.2996661067008972     │    0.6719532608985901     │    0.5893155336380005     │\n",
+       "│       test/l1_loss        │    204.13099670410156     │     168.3704376220703     │     173.6667022705078     │\n",
+       "│       test/l2_loss        │     3314.19677734375      │     4195.55810546875      │         5150.125          │\n",
+       "│      test/loss_pred       │    0.24005833268165588    │    0.10902327299118042    │    0.2060735672712326     │\n",
+       "│       test/loss_rec       │      3334.6103515625      │      4212.3955078125      │     5167.49072265625      │\n",
+       "│          test/n           │          2396.0           │          1198.0           │          1198.0           │\n",
+       "└───────────────────────────┴───────────────────────────┴───────────────────────────┴───────────────────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1m Test metric \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m DataLoader 0 \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m DataLoader 1 \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m DataLoader 2 \u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", + "│\u001b[36m \u001b[0m\u001b[36m test/acc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.2996661067008972 \u001b[0m\u001b[35m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.6719532608985901 \u001b[0m\u001b[35m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.5893155336380005 \u001b[0m\u001b[35m \u001b[0m│\n", + "│\u001b[36m \u001b[0m\u001b[36m test/l1_loss \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 204.13099670410156 \u001b[0m\u001b[35m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 168.3704376220703 \u001b[0m\u001b[35m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 173.6667022705078 \u001b[0m\u001b[35m \u001b[0m│\n", + "│\u001b[36m \u001b[0m\u001b[36m test/l2_loss \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 3314.19677734375 \u001b[0m\u001b[35m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 4195.55810546875 \u001b[0m\u001b[35m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 5150.125 \u001b[0m\u001b[35m \u001b[0m│\n", + "│\u001b[36m \u001b[0m\u001b[36m test/loss_pred \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.24005833268165588 \u001b[0m\u001b[35m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.10902327299118042 \u001b[0m\u001b[35m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.2060735672712326 \u001b[0m\u001b[35m \u001b[0m│\n", + "│\u001b[36m \u001b[0m\u001b[36m test/loss_rec \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 3334.6103515625 \u001b[0m\u001b[35m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 4212.3955078125 \u001b[0m\u001b[35m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 5167.49072265625 \u001b[0m\u001b[35m \u001b[0m│\n", + "│\u001b[36m \u001b[0m\u001b[36m test/n \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 2396.0 \u001b[0m\u001b[35m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 1198.0 \u001b[0m\u001b[35m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 1198.0 \u001b[0m\u001b[35m \u001b[0m│\n", + "└───────────────────────────┴───────────────────────────┴───────────────────────────┴───────────────────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
+       "┃        Test metric        ┃       DataLoader 3        ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
+       "│         test/acc          │    0.43926939368247986    │\n",
+       "│       test/l1_loss        │     168.7139129638672     │\n",
+       "│       test/l2_loss        │       4968.8515625        │\n",
+       "│      test/loss_pred       │    0.18025663495063782    │\n",
+       "│       test/loss_rec       │       4985.72265625       │\n",
+       "│          test/n           │          1095.0           │\n",
+       "└───────────────────────────┴───────────────────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1m Test metric \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m DataLoader 3 \u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", + "│\u001b[36m \u001b[0m\u001b[36m test/acc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.43926939368247986 \u001b[0m\u001b[35m \u001b[0m│\n", + "│\u001b[36m \u001b[0m\u001b[36m test/l1_loss \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 168.7139129638672 \u001b[0m\u001b[35m \u001b[0m│\n", + "│\u001b[36m \u001b[0m\u001b[36m test/l2_loss \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 4968.8515625 \u001b[0m\u001b[35m \u001b[0m│\n", + "│\u001b[36m \u001b[0m\u001b[36m test/loss_pred \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.18025663495063782 \u001b[0m\u001b[35m \u001b[0m│\n", + "│\u001b[36m \u001b[0m\u001b[36m test/loss_rec \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 4985.72265625 \u001b[0m\u001b[35m \u001b[0m│\n", + "│\u001b[36m \u001b[0m\u001b[36m test/n \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 1095.0 \u001b[0m\u001b[35m \u001b[0m│\n", + "└───────────────────────────┴───────────────────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Predicting DataLoader 0: 100%|██████████| 19/19 [00:00<00:00, 31.54it/s]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Predicting DataLoader 0: 100%|██████████| 19/19 [00:00<00:00, 31.27it/s]\n", + "probe results on subsets of the data\n", + "acc=63.06%,\tn=2396,\t[] \n", + "acc=68.01%,\tn=1016,\t[instructed_to_lie==True] \n", + "acc=59.42%,\tn=1380,\t[instructed_to_lie==False] \n", + "acc=65.61%,\tn=2265,\t[llm_ans==label_true] \n", + "acc=55.92%,\tn=1511,\t[llm_ans==label_instructed] \n", + "acc=19.08%,\tn=131,\t[instructed_to_lie==True & llm_ans==label_instructed] \n", + "acc=75.25%,\tn=885,\t[instructed_to_lie==True & llm_ans!=label_instructed] \n", + "probe accuracy for quadrants\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
llm gavediddidn't
instructed to
tell a truth0.59NaN
tell a lie0.190.75
\n", + "
" + ], + "text/plain": [ + "llm gave did didn't\n", + "instructed to \n", + "tell a truth 0.59 NaN\n", + "tell a lie 0.19 0.75" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "⭐PRIMARY METRIC⭐ acc=63.06% from probe\n", + "⭐SECONDARY METRIC⭐ acc_lie_lie=19.08% from probe\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "# look at hist\n", + "df_hist = read_metrics_csv(trainer2.logger.experiment.metrics_file_path).ffill().bfill()\n", + "for key in ['loss_pred']:\n", + " df_hist[[c for c in df_hist.columns if key in c]].plot()\n", + " \n", + "for key in ['acc']:\n", + " df_hist[[c for c in df_hist.columns if key in c]].plot()\n", + "df_hist\n", + "\n", + "# predict\n", + "dl_test = dm.test_dataloader()\n", + "# print(f\"training with x_feats={x_feats} with c={c}\")\n", + "rs = trainer2.test(net, dataloaders=[dl_train, dl_val, dl_test, dl_oos])\n", + "\n", + "testval_metrics = calc_metrics(dm, trainer2, net, use_val=True)\n", + "rs = rename(rs, ['train', 'val', 'test', 'oos'])\n", + "# rs['test'] = {**rs['test'], **test_metrics}\n", + "rs['test']['acc_lie_lie'] = testval_metrics['acc_lie_lie']\n", + "rs['testval_metrics'] = rs['test']\n" + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 45, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Testing DataLoader 0: 100%|██████████| 18/18 [00:00<00:00, 27.25it/s]\n" + ] + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
+       "┃        Test metric        ┃       DataLoader 0        ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
+       "│         test/acc          │    0.43926939368247986    │\n",
+       "│       test/l1_loss        │     168.7139129638672     │\n",
+       "│       test/l2_loss        │       4968.8515625        │\n",
+       "│      test/loss_pred       │    0.18025663495063782    │\n",
+       "│       test/loss_rec       │       4985.72265625       │\n",
+       "│          test/n           │          1095.0           │\n",
+       "└───────────────────────────┴───────────────────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1m Test metric \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m DataLoader 0 \u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", + "│\u001b[36m \u001b[0m\u001b[36m test/acc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.43926939368247986 \u001b[0m\u001b[35m \u001b[0m│\n", + "│\u001b[36m \u001b[0m\u001b[36m test/l1_loss \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 168.7139129638672 \u001b[0m\u001b[35m \u001b[0m│\n", + "│\u001b[36m \u001b[0m\u001b[36m test/l2_loss \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 4968.8515625 \u001b[0m\u001b[35m \u001b[0m│\n", + "│\u001b[36m \u001b[0m\u001b[36m test/loss_pred \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.18025663495063782 \u001b[0m\u001b[35m \u001b[0m│\n", + "│\u001b[36m \u001b[0m\u001b[36m test/loss_rec \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 4985.72265625 \u001b[0m\u001b[35m \u001b[0m│\n", + "│\u001b[36m \u001b[0m\u001b[36m test/n \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 1095.0 \u001b[0m\u001b[35m \u001b[0m│\n", + "└───────────────────────────┴───────────────────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Predicting DataLoader 0: 100%|██████████| 5/5 [00:00<00:00, 34.54it/s]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Predicting DataLoader 0: 100%|██████████| 5/5 [00:00<00:00, 35.48it/s]\n", + "probe results on subsets of the data\n", + "acc=42.70%,\tn=548,\t[] \n", + "acc=41.46%,\tn=205,\t[instructed_to_lie==True] \n", + "acc=43.44%,\tn=343,\t[instructed_to_lie==False] \n", + "acc=45.53%,\tn=503,\t[llm_ans==label_true] \n", + "acc=39.69%,\tn=388,\t[llm_ans==label_instructed] \n", + "acc=11.11%,\tn=45,\t[instructed_to_lie==True & llm_ans==label_instructed] \n", + "acc=50.00%,\tn=160,\t[instructed_to_lie==True & llm_ans!=label_instructed] \n", + "probe accuracy for quadrants\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
llm gavediddidn't
instructed to
tell a truth0.43NaN
tell a lie0.110.5
\n", + "
" + ], + "text/plain": [ + "llm gave did didn't\n", + "instructed to \n", + "tell a truth 0.43 NaN\n", + "tell a lie 0.11 0.5" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "⭐PRIMARY METRIC⭐ acc=42.70% from probe\n", + "⭐SECONDARY METRIC⭐ acc_lie_lie=11.11% from probe\n" + ] + }, + { + "data": { + "text/plain": [ + "{'train': {'acc': 0.2996661067008972,\n", + " 'loss_pred': 0.24005833268165588,\n", + " 'loss_rec': 3334.6103515625,\n", + " 'l1_loss': 204.13099670410156,\n", + " 'l2_loss': 3314.19677734375,\n", + " 'n': 2396.0},\n", + " 'val': {'acc': 0.6719532608985901,\n", + " 'loss_pred': 0.10902327299118042,\n", + " 'loss_rec': 4212.3955078125,\n", + " 'l1_loss': 168.3704376220703,\n", + " 'l2_loss': 4195.55810546875,\n", + " 'n': 1198.0},\n", + " 'test': {'acc': 0.5893155336380005,\n", + " 'loss_pred': 0.2060735672712326,\n", + " 'loss_rec': 5167.49072265625,\n", + " 'l1_loss': 173.6667022705078,\n", + " 'l2_loss': 5150.125,\n", + " 'n': 1198.0,\n", + " 'acc_lie_lie': 0.19083969465648856},\n", + " 'oos': {'acc': 0.43926939368247986,\n", + " 'loss_pred': 0.18025663495063782,\n", + " 'loss_rec': 4985.72265625,\n", + " 'l1_loss': 168.7139129638672,\n", + " 'l2_loss': 4968.8515625,\n", + " 'n': 1095.0,\n", + " 'acc_lie_lie': 0.1111111111111111},\n", + " 'testval_metrics': {'acc': 0.5893155336380005,\n", + " 'loss_pred': 0.2060735672712326,\n", + " 'loss_rec': 5167.49072265625,\n", + " 'l1_loss': 173.6667022705078,\n", + " 'l2_loss': 5150.125,\n", + " 'n': 1198.0,\n", + " 'acc_lie_lie': 0.19083969465648856},\n", + " 'oos_metrics': {'test/acc': 0.43926939368247986,\n", + " 'test/loss_pred': 0.18025663495063782,\n", + " 'test/loss_rec': 4985.72265625,\n", + " 'test/l1_loss': 168.7139129638672,\n", + " 'test/l2_loss': 4968.8515625,\n", + " 'test/n': 1095.0}}" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# print(f\"training with x_feats={x_feats} with c={c}\")\n", + "rs2 = trainer1.test(net, dataloaders=[dl_oos])\n", + "rs2 = rename(rs2, ks=['oos'])\n", + "\n", + "testval_metrics2 = calc_metrics(dm_oos, trainer1, net, use_val=True)\n", + "rs['oos']['acc_lie_lie'] = testval_metrics2['acc_lie_lie']\n", + "rs['oos_metrics'] = rs2['oos']\n", + "rs\n" + ] }, { "cell_type": "code", diff --git a/src/datasets/batch.py b/src/datasets/batch.py index 20bc5a8..23632cd 100644 --- a/src/datasets/batch.py +++ b/src/datasets/batch.py @@ -1,68 +1,68 @@ -from tqdm.auto import tqdm -import torch -from torch.utils.data import DataLoader -from datasets.arrow_dataset import Dataset -import hashlib -import pickle -import numpy as np -from typing import List, Dict, Any, Union, NewType, Optional +# from tqdm.auto import tqdm +# import torch +# from torch.utils.data import DataLoader +# from datasets.arrow_dataset import Dataset +# import hashlib +# import pickle +# import numpy as np +# from typing import List, Dict, Any, Union, NewType, Optional -from src.datasets.hs import ExtractHiddenStates -from src.helpers.typing import float_to_int16, int16_to_float -from src.helpers.ds import ds_keep_cols, clear_mem -from src.datasets.intervene import InterventionDict +# from src.datasets.hs import ExtractHiddenStates +# from src.helpers.typing import float_to_int16, int16_to_float +# from src.helpers.ds import ds_keep_cols, clear_mem +# from src.datasets.intervene import InterventionDict -def batch_hidden_states(model, tokenizer, intervention_dicts: Optional[InterventionDict], data: Dataset, batch_size=2, layer_padding=3, layer_stride=4): - """ - Given an encoder-decoder model, a list of data, computes the contrast hidden states on n random examples. - Returns numpy arrays of shape (n, hidden_dim) for each candidate label, along with a boolean numpy array of shape (n,) - with the ground truth labels +# def batch_hidden_states(model, tokenizer, intervention_dicts: Optional[InterventionDict], data: Dataset, batch_size=2, layer_padding=3, layer_stride=4): +# """ +# Given an encoder-decoder model, a list of data, computes the contrast hidden states on n random examples. +# Returns numpy arrays of shape (n, hidden_dim) for each candidate label, along with a boolean numpy array of shape (n,) +# with the ground truth labels - This is deliberately simple so that it's easy to understand, rather than being optimized for efficiency - """ - ehs = ExtractHiddenStates(model, tokenizer, intervention_dicts=intervention_dicts, layer_stride=layer_stride, layer_padding=layer_padding) +# This is deliberately simple so that it's easy to understand, rather than being optimized for efficiency +# """ +# ehs = ExtractHiddenStates(model, tokenizer, intervention_dicts=intervention_dicts, layer_stride=layer_stride, layer_padding=layer_padding) - torch_cols = ['input_ids', 'attention_mask', 'choice_ids'] - ds_t_subset = ds_keep_cols(data, torch_cols) - ds_t_subset.set_format(type='torch') +# torch_cols = ['input_ids', 'attention_mask', 'choice_ids'] +# ds_t_subset = ds_keep_cols(data, torch_cols) +# ds_t_subset.set_format(type='torch') - ds_p_subset = data.remove_columns(torch_cols) +# ds_p_subset = data.remove_columns(torch_cols) - dl = DataLoader(ds_t_subset, batch_size=batch_size, shuffle=False) - for i, batch in enumerate(tqdm(dl, desc='get hidden states')): - input_ids, attention_mask, choice_ids = batch["input_ids"], batch["attention_mask"], batch["choice_ids"] - nn = len(input_ids) - index = i*batch_size+np.arange(nn) +# dl = DataLoader(ds_t_subset, batch_size=batch_size, shuffle=False) +# for i, batch in enumerate(tqdm(dl, desc='get hidden states')): +# input_ids, attention_mask, choice_ids = batch["input_ids"], batch["attention_mask"], batch["choice_ids"] +# nn = len(input_ids) +# index = i*batch_size+np.arange(nn) - # different due to dropout - hsl = ehs.get_batch_of_hidden_states(input_ids=input_ids, attention_mask=attention_mask, choice_ids=choice_ids) +# # different due to dropout +# hsl = ehs.get_batch_of_hidden_states(input_ids=input_ids, attention_mask=attention_mask, choice_ids=choice_ids) - for j in range(nn): - # let's add the non torch metadata like label, prompt, lie, etc - k = i*batch_size + j - info = ds_p_subset[k] +# for j in range(nn): +# # let's add the non torch metadata like label, prompt, lie, etc +# k = i*batch_size + j +# info = ds_p_subset[k] - large_arrays_keys = [k for k,v in hsl.items() if isinstance(v, torch.Tensor) and v.ndim>2] +# large_arrays_keys = [k for k,v in hsl.items() if isinstance(v, torch.Tensor) and v.ndim>2] - # TODO deal with multiple lists of hs in hs0 - large_arrays = {k:hsl[k][j] for k in large_arrays_keys} +# # TODO deal with multiple lists of hs in hs0 +# large_arrays = {k:hsl[k][j] for k in large_arrays_keys} - yield dict( +# yield dict( - # large_arrays_keys=large_arrays_keys, - scores0=hsl["scores"][j], - # layer_names=hsl["layers"][j] if k==0 else [], # just in the first one, to save space +# # large_arrays_keys=large_arrays_keys, +# scores0=hsl["scores"][j], +# # layer_names=hsl["layers"][j] if k==0 else [], # just in the first one, to save space - ds_index=index[j], +# ds_index=index[j], - # int16 makes our storage much smaller - **large_arrays, +# # int16 makes our storage much smaller +# **large_arrays, - **info - ) +# **info +# ) - info = large_arrays = hsl = None - clear_mem() +# info = large_arrays = hsl = None +# clear_mem() diff --git a/src/datasets/dm.py b/src/datasets/dm.py index 2db8dab..d9628b5 100644 --- a/src/datasets/dm.py +++ b/src/datasets/dm.py @@ -32,12 +32,14 @@ class imdbHSDataModule(pl.LightningDataModule): batch_size: int=32, x_cols = ['end_hidden_states'], skip_layers = 0, + use_diff = True, ): super().__init__() self.save_hyperparameters(ignore=["ds"]) self.ds = ds self.x_cols = x_cols self.skip_layers = skip_layers + self.use_diff = use_diff def setup(self, stage: str): h = self.hparams @@ -61,7 +63,8 @@ class imdbHSDataModule(pl.LightningDataModule): b = len(self.ds_hs) # take the diff between layers. Shape batch, layers, hidden_states, inferences hs = torch.tensor(self.ds_hs['end_hidden_states']) - hs = hs.diff(1, axis=1) # this makes it the residual between layers + if self.use_diff: + hs = hs.diff(1, axis=1) # this makes it the residual between layers if self.skip_layers: hs = hs[:, self.skip_layers:] # drop the first 10 layers to prevent overfitting? self.hs0 = hs[..., 0] diff --git a/src/datasets/hs.py b/src/datasets/hs.py index f7077b9..db21c4a 100644 --- a/src/datasets/hs.py +++ b/src/datasets/hs.py @@ -1,220 +1,220 @@ -from dataclasses import dataclass -import lightning as pl -from loguru import logger -from transformers import ( - AutoTokenizer, - AutoModelForSeq2SeqLM, - AutoModelForMaskedLM, - AutoModelForCausalLM, - AutoConfig, - AutoModel, - PreTrainedTokenizer, - PreTrainedModel -) -from typing import Optional, List, Tuple, Dict, NewType -from transformers import LogitsProcessorList -import functools -from src.helpers.torch import to_numpy -from src.datasets.dropout import enable_dropout -import re +# from dataclasses import dataclass +# import lightning as pl +# from loguru import logger +# from transformers import ( +# AutoTokenizer, +# AutoModelForSeq2SeqLM, +# AutoModelForMaskedLM, +# AutoModelForCausalLM, +# AutoConfig, +# AutoModel, +# PreTrainedTokenizer, +# PreTrainedModel +# ) +# from typing import Optional, List, Tuple, Dict, NewType +# from transformers import LogitsProcessorList +# import functools +# from src.helpers.torch import to_numpy +# from src.datasets.dropout import enable_dropout +# import re -from tqdm.auto import tqdm -# from src.datasets.hs import ExtractHiddenStates -from torch.utils.data import DataLoader -from datasets import Dataset -import numpy as np -import torch -import torch.nn.functional as F -from baukit.nethook import Trace, TraceDict, recursive_copy -from einops import rearrange, reduce, repeat -from src.datasets.scores import choice2id, choice2ids -from src.helpers.torch import clear_mem, detachcpu -from collections import defaultdict -from dataclasses import field -from src.datasets.intervene import InterventionDict, intervention_meta_fn -from functools import partial +# from tqdm.auto import tqdm +# # from src.datasets.hs import ExtractHiddenStates +# from torch.utils.data import DataLoader +# from datasets import Dataset +# import numpy as np +# import torch +# import torch.nn.functional as F +# from baukit.nethook import Trace, TraceDict, recursive_copy +# from einops import rearrange, reduce, repeat +# from src.datasets.scores import choice2id, choice2ids +# from src.helpers.torch import clear_mem, detachcpu +# from collections import defaultdict +# from dataclasses import field +# from src.datasets.intervene import InterventionDict, intervention_meta_fn +# from functools import partial -# def noise_for_embeds(inputs_embeds, seed=42, std = 2e-2): -# B, S, embed_dim = inputs_embeds.shape -# with torch.random.fork_rng(devices=[inputs_embeds.device.index]): -# torch.manual_seed(seed) -# noise = torch.normal(0., std, (embed_dim, )) -# noise = repeat(noise, 't -> b s t', b=B, s=S).to(inputs_embeds.device).to(inputs_embeds.dtype) -# return noise +# # def noise_for_embeds(inputs_embeds, seed=42, std = 2e-2): +# # B, S, embed_dim = inputs_embeds.shape +# # with torch.random.fork_rng(devices=[inputs_embeds.device.index]): +# # torch.manual_seed(seed) +# # noise = torch.normal(0., std, (embed_dim, )) +# # noise = repeat(noise, 't -> b s t', b=B, s=S).to(inputs_embeds.device).to(inputs_embeds.dtype) +# # return noise -def tcopy(x: torch.Tensor): - return x.clone().detach().cpu() +# def tcopy(x: torch.Tensor): +# return x.clone().detach().cpu() -def counterfactual_loss(model, scores, token_y, token_n): - """do a backwards pass where the loss is the distance to the opposite scores""" - eps = 1e-4 - model.zero_grad() - assert token_y.shape[1]<2, 'FIXME just use the first token for now' - score_y = torch.index_select(scores, 1, token_y[:, 0]) - score_n = torch.index_select(scores, 1, token_n[:, 0]) - # this loss would be zero if the logits of the positive and negative tokens werre flipped - loss = F.l1_loss(score_y, score_n) + F.l1_loss(score_n, score_y) - return loss +# def counterfactual_loss(model, scores, token_y, token_n): +# """do a backwards pass where the loss is the distance to the opposite scores""" +# eps = 1e-4 +# model.zero_grad() +# assert token_y.shape[1]<2, 'FIXME just use the first token for now' +# score_y = torch.index_select(scores, 1, token_y[:, 0]) +# score_n = torch.index_select(scores, 1, token_n[:, 0]) +# # this loss would be zero if the logits of the positive and negative tokens werre flipped +# loss = F.l1_loss(score_y, score_n) + F.l1_loss(score_n, score_y) +# return loss -def stack_trace_returns(ret: TraceDict, names: List[str]) -> torch.Tensor: - hs = [ret[h].output for h in names] - hs = [h[0] if isinstance(h, tuple) else h for h in hs] # from a head it's a tuple - return rearrange(hs, 'layers b s hs -> b layers s hs')[:, :, -1] - -# def stack_trace_grad_returns(ret: TraceDict, names: List[str]) -> torch.Tensor: -# hs = [ret[h].output.grad.detach() for h in names] +# def stack_trace_returns(ret: TraceDict, names: List[str]) -> torch.Tensor: +# hs = [ret[h].output for h in names] +# hs = [h[0] if isinstance(h, tuple) else h for h in hs] # from a head it's a tuple # return rearrange(hs, 'layers b s hs -> b layers s hs')[:, :, -1] -# def select_weight_grads(weight_grads: Dict[str, torch.Tensor], pattern:str= ".+attn.c_proj.weight", mean_axis:int=1): -# grads = [g.mean(mean_axis) for k,g in weight_grads.items() if re.match(pattern, k)] -# assert len(grads), f"non of pattern='{pattern}' found in {weight_grads.keys()}" -# return rearrange(grads, "lyrs b hs -> b lyrs hs") +# # def stack_trace_grad_returns(ret: TraceDict, names: List[str]) -> torch.Tensor: +# # hs = [ret[h].output.grad.detach() for h in names] +# # return rearrange(hs, 'layers b s hs -> b layers s hs')[:, :, -1] + +# # def select_weight_grads(weight_grads: Dict[str, torch.Tensor], pattern:str= ".+attn.c_proj.weight", mean_axis:int=1): +# # grads = [g.mean(mean_axis) for k,g in weight_grads.items() if re.match(pattern, k)] +# # assert len(grads), f"non of pattern='{pattern}' found in {weight_grads.keys()}" +# # return rearrange(grads, "lyrs b hs -> b lyrs hs") -@dataclass -class ExtractHiddenStates: +# @dataclass +# class ExtractHiddenStates: - model: PreTrainedModel - tokenizer: PreTrainedTokenizer - intervention_dicts: Optional[InterventionDict] = None - layer_stride: int = 8 - layer_padding: int = 3 +# model: PreTrainedModel +# tokenizer: PreTrainedTokenizer +# intervention_dicts: Optional[InterventionDict] = None +# layer_stride: int = 8 +# layer_padding: int = 3 - def get_layer_names(self): - # for WizardLM/WizardCoder-3B-V1.0 - # HEADS = [f"transformer.h.{i}.attn.c_proj" for i in range(self.model.config.num_hidden_layers)] - # MLPS = [f"transformer.h.{i}.mlp" for i in range(self.model.config.num_hidden_layers)] +# def get_layer_names(self): +# # for WizardLM/WizardCoder-3B-V1.0 +# # HEADS = [f"transformer.h.{i}.attn.c_proj" for i in range(self.model.config.num_hidden_layers)] +# # MLPS = [f"transformer.h.{i}.mlp" for i in range(self.model.config.num_hidden_layers)] - # for "WizardLM/WizardCoder-Python-13B-V1.0" - # HACK: depends on model layout - layers_names_h = [f"model.layers.{i}.self_attn" for i in range(self.model.config.num_hidden_layers)] - layers_names_mlp = [f"model.layers.{i}.mlp" for i in range(self.model.config.num_hidden_layers)] - return self.get_layer_selection(layers_names_h) + self.get_layer_selection(layers_names_mlp) +# # for "WizardLM/WizardCoder-Python-13B-V1.0" +# # HACK: depends on model layout +# layers_names_h = [f"model.layers.{i}.self_attn" for i in range(self.model.config.num_hidden_layers)] +# layers_names_mlp = [f"model.layers.{i}.mlp" for i in range(self.model.config.num_hidden_layers)] +# return self.get_layer_selection(layers_names_h) + self.get_layer_selection(layers_names_mlp) - def get_batch_of_hidden_states( - self, - input_text: Optional[List[str]] = None, - input_ids: torch.Tensor = None, - attention_mask: Optional[torch.Tensor] = None, - choice_ids: List[torch.Tensor] = None, - truncation_length=999, - debug=False, - ): - """ - Given a decoder model and a batch of texts, gets a pair of hidden states (in a given layer) on that input texts +# def get_batch_of_hidden_states( +# self, +# input_text: Optional[List[str]] = None, +# input_ids: torch.Tensor = None, +# attention_mask: Optional[torch.Tensor] = None, +# choice_ids: List[torch.Tensor] = None, +# truncation_length=999, +# debug=False, +# ): +# """ +# Given a decoder model and a batch of texts, gets a pair of hidden states (in a given layer) on that input texts - The idea is this: given two pairs of hidden states, where everything is the same except r dropout. Then tell me which one is more truthful? - """ - assert (input_ids is not None) or (input_text is not None), "need to provide input_ids or input_text" - assert self.tokenizer.truncation_side == 'left' +# The idea is this: given two pairs of hidden states, where everything is the same except r dropout. Then tell me which one is more truthful? +# """ +# assert (input_ids is not None) or (input_text is not None), "need to provide input_ids or input_text" +# assert self.tokenizer.truncation_side == 'left' - if input_text: - raise NotImplementedError("FIXME") - t = self.tokenizer( - input_text, - return_tensors="pt", - add_special_tokens=True, - padding='max_length', max_length=truncation_length, truncation=True, return_attention_mask=True, - ) - input_ids = t.input_ids.to(self.model.device) - attention_mask = t.attention_mask.to(self.model.device) - else: - input_ids = input_ids.to(self.model.device) - attention_mask = attention_mask.to(self.model.device) - choice_ids = choice_ids.to(self.model.device) +# if input_text: +# raise NotImplementedError("FIXME") +# t = self.tokenizer( +# input_text, +# return_tensors="pt", +# add_special_tokens=True, +# padding='max_length', max_length=truncation_length, truncation=True, return_attention_mask=True, +# ) +# input_ids = t.input_ids.to(self.model.device) +# attention_mask = t.attention_mask.to(self.model.device) +# else: +# input_ids = input_ids.to(self.model.device) +# attention_mask = attention_mask.to(self.model.device) +# choice_ids = choice_ids.to(self.model.device) - # forward pass - last_token = -1 +# # forward pass +# last_token = -1 - layers_names = self.get_layer_names() +# layers_names = self.get_layer_names() - self.model.eval() +# self.model.eval() - if self.intervention_dicts is not None: - # extraction mode - # 15 is a magic number from honest_llama - intervention_fn1 = partial(intervention_meta_fn, interventions=self.intervention_dicts, alpha=-15) - intervention_fn2 = partial(intervention_meta_fn, interventions=self.intervention_dicts, alpha=15) - edit_outputs = [intervention_fn1, intervention_fn2] - else: - # calibration mode - edit_outputs = [None] +# if self.intervention_dicts is not None: +# # extraction mode +# # 15 is a magic number from honest_llama +# intervention_fn1 = partial(intervention_meta_fn, interventions=self.intervention_dicts, alpha=-15) +# intervention_fn2 = partial(intervention_meta_fn, interventions=self.intervention_dicts, alpha=15) +# edit_outputs = [intervention_fn1, intervention_fn2] +# else: +# # calibration mode +# edit_outputs = [None] - with torch.no_grad(): - multi_outs = defaultdict(list) - for edit_output in edit_outputs: - with TraceDict(self.model, layers_names, retain_grad=False, detach=True, edit_output=edit_output) as ret: - model_inputs = self.model.prepare_inputs_for_generation(input_ids=input_ids, attention_mask=attention_mask, use_cache=False) - outputs = self.model.forward( - **model_inputs, - return_dict=True, - output_hidden_states=True, - ) - outputs["scores"] = outputs.logits[:, last_token, :].float() +# with torch.no_grad(): +# multi_outs = defaultdict(list) +# for edit_output in edit_outputs: +# with TraceDict(self.model, layers_names, retain_grad=False, detach=True, edit_output=edit_output) as ret: +# model_inputs = self.model.prepare_inputs_for_generation(input_ids=input_ids, attention_mask=attention_mask, use_cache=False) +# outputs = self.model.forward( +# **model_inputs, +# return_dict=True, +# output_hidden_states=True, +# ) +# outputs["scores"] = outputs.logits[:, last_token, :].float() - # stack - hidden_states = list(outputs.hidden_states) - hidden_states = rearrange(hidden_states, 'lyrs b seq hs -> b lyrs seq hs')[:, :, last_token] - ## from ret, we get the layer activation and the grads on them - head_activation = tcopy(stack_trace_returns(ret, layers_names)) - # mlp_activation = tcopy(stack_trace_returns(ret, MLPS)) +# # stack +# hidden_states = list(outputs.hidden_states) +# hidden_states = rearrange(hidden_states, 'lyrs b seq hs -> b lyrs seq hs')[:, :, last_token] +# ## from ret, we get the layer activation and the grads on them +# head_activation = tcopy(stack_trace_returns(ret, layers_names)) +# # mlp_activation = tcopy(stack_trace_returns(ret, MLPS)) - # collect outputs - multi_outs['scores'].append(outputs["scores"]) - # multi_outs['hidden_states'].append(hidden_states) - multi_outs['head_activation'].append(head_activation) - # multi_outs['mlp_activation'].append(mlp_activation) +# # collect outputs +# multi_outs['scores'].append(outputs["scores"]) +# # multi_outs['hidden_states'].append(hidden_states) +# multi_outs['head_activation'].append(head_activation) +# # multi_outs['mlp_activation'].append(mlp_activation) - # stack - multi_outs['scores'] = torch.stack(multi_outs['scores'], -1) - # multi_outs['mlp_activation'] = torch.stack(multi_outs['mlp_activation'], -1) - multi_outs['head_activation'] = torch.stack(multi_outs['head_activation'], -1) +# # stack +# multi_outs['scores'] = torch.stack(multi_outs['scores'], -1) +# # multi_outs['mlp_activation'] = torch.stack(multi_outs['mlp_activation'], -1) +# multi_outs['head_activation'] = torch.stack(multi_outs['head_activation'], -1) - # combine - out_common = dict(input_ids=input_ids, attention_mask=attention_mask, layers=layers_names,) - if debug: - out_common['input_truncated'] = self.tokenizer.batch_decode(input_ids) - out_common['text_ans'] = self.tokenizer.batch_decode(outputs["scores"].softmax(-1).argmax(-1)) +# # combine +# out_common = dict(input_ids=input_ids, attention_mask=attention_mask, layers=layers_names,) +# if debug: +# out_common['input_truncated'] = self.tokenizer.batch_decode(input_ids) +# out_common['text_ans'] = self.tokenizer.batch_decode(outputs["scores"].softmax(-1).argmax(-1)) - out = {**multi_outs, **out_common} +# out = {**multi_outs, **out_common} - # detach - out = {k: detachcpu(v) for k, v in out.items()} +# # detach +# out = {k: detachcpu(v) for k, v in out.items()} - # I shouldn't have to do this but I get memory leaks - outputs = hidden_states = hidden_states2 = loss = orig_state_dict = scores = token_y = token_n = input_ids = attention_mask = choice_ids = residual_stream = residual_stream2 = None - clear_mem() - return out +# # I shouldn't have to do this but I get memory leaks +# outputs = hidden_states = hidden_states2 = loss = orig_state_dict = scores = token_y = token_n = input_ids = attention_mask = choice_ids = residual_stream = residual_stream2 = None +# clear_mem() +# return out - def get_layer_selection(self, layer_names): - """Sometimes we don't want to save all layers. +# def get_layer_selection(self, layer_names): +# """Sometimes we don't want to save all layers. - We skip the first few (data leakage?). Stride the the middle (could be valuable), and include the last few (possibly high level concepts). +# We skip the first few (data leakage?). Stride the the middle (could be valuable), and include the last few (possibly high level concepts). - See also https://www.lesswrong.com/posts/bWxNPMy5MhPnQTzKz/what-discovering-latent-knowledge-did-and-did-not-find-4 - """ - module_names = [k for k,v in self.model.named_modules()] - layers_not_found = set(layer_names)-set(module_names) - assert len(layers_not_found)==0, f"some layers not found in model: {layers_not_found}. we have {layer_names}" +# See also https://www.lesswrong.com/posts/bWxNPMy5MhPnQTzKz/what-discovering-latent-knowledge-did-and-did-not-find-4 +# """ +# module_names = [k for k,v in self.model.named_modules()] +# layers_not_found = set(layer_names)-set(module_names) +# assert len(layers_not_found)==0, f"some layers not found in model: {layers_not_found}. we have {layer_names}" - # for self.layer_padding, skip the first few - num_layers = len(layer_names)-1 - strided_layers = torch.arange( - self.layer_padding, - num_layers-self.layer_padding, - self.layer_stride, - ).tolist() - # for self.layer_padding ALWAYS include the last few. Why, this is based on the intuition that the last layers may be the most valuable - last_few = torch.arange(num_layers-self.layer_padding, num_layers).tolist() - layers_inds = sorted(set(list(strided_layers)+list(last_few))) - return [layer_names[i] for i in layers_inds] +# # for self.layer_padding, skip the first few +# num_layers = len(layer_names)-1 +# strided_layers = torch.arange( +# self.layer_padding, +# num_layers-self.layer_padding, +# self.layer_stride, +# ).tolist() +# # for self.layer_padding ALWAYS include the last few. Why, this is based on the intuition that the last layers may be the most valuable +# last_few = torch.arange(num_layers-self.layer_padding, num_layers).tolist() +# layers_inds = sorted(set(list(strided_layers)+list(last_few))) +# return [layer_names[i] for i in layers_inds] diff --git a/src/datasets/intervene.py b/src/datasets/intervene.py index 4d2a4d7..6c5d3ce 100644 --- a/src/datasets/intervene.py +++ b/src/datasets/intervene.py @@ -67,6 +67,7 @@ def create_cache_interventions(model, tokenizer, cfg, N_fit_examples=20, batch_s train_labels = np.array(dataset_fit['label_true']) if get_negative: + # FIXME: does this work with PCA, since it's directionless train_labels = -1 * train_labels rep_reading_pipeline = pipeline("rep-reading", model=model, tokenizer=tokenizer) honesty_rep_reader = rep_reading_pipeline.get_directions( diff --git a/src/probes/pl_ranking.py b/src/probes/pl_ranking.py index 326d9f7..f025a4b 100644 --- a/src/probes/pl_ranking.py +++ b/src/probes/pl_ranking.py @@ -163,7 +163,8 @@ class PLConvProbeLinear(PLRankingBase): self.head = nn.Sequential( LinBnDrop(n, n), LinBnDrop(n, n), - nn.Linear(n, 1), + nn.Linear(n, 1), + # nn.Tanh(), ) def forward(self, x): diff --git a/src/repe/rep_control_pipeline_baukit.py b/src/repe/rep_control_pipeline_baukit.py index b6327a2..40f8dcf 100644 --- a/src/repe/rep_control_pipeline_baukit.py +++ b/src/repe/rep_control_pipeline_baukit.py @@ -87,7 +87,8 @@ class RepControlPipeline2(FeatureExtractionPipeline): assert inputs['input_ids'].ndim == 2, f"expected input_ids to be (batch, seq), got {inputs['input_ids'].shape}" # make intervention functions - layers_names = [self.layer_name_tmpl.format(i) for i in activations[0].keys()] + layers_names = [self.layer_name_tmpl.format(i) for i in activations[0].keys()] + # FIXME: [0] is positive, [1] is negative. We can also multiply by -1, 0, or 1 activations_pos_i = Activations({self.layer_name_tmpl.format(k):v for k,v in activations[1].items()}) activations_neut = Activations({self.layer_name_tmpl.format(k):0. * v for k,v in activations[0].items()}) edit_fn_pos = partial(intervention_meta_fn2, activations=activations_pos_i) diff --git a/src/repe/rep_reading_pipeline.py b/src/repe/rep_reading_pipeline.py index a71d137..7d1bac9 100644 --- a/src/repe/rep_reading_pipeline.py +++ b/src/repe/rep_reading_pipeline.py @@ -140,6 +140,7 @@ class RepReadingPipeline(Pipeline): relative_hidden_states = {k: np.copy(v) for k, v in hidden_states.items()} for layer in hidden_layers: for _ in range(n_difference): + # TODO: check this, it's even - odd? on what dimension? relative_hidden_states[layer] = relative_hidden_states[layer][::2] - relative_hidden_states[layer][1::2] # get the directions